From 755e78dfb9502fc48fd82742bcc13e9d25a2accc Mon Sep 17 00:00:00 2001
From: Pranav Gaddamadugu <23022326+d0cd@users.noreply.github.com>
Date: Sun, 28 Jul 2024 09:50:22 -0700
Subject: [PATCH 1/5] Some cleanup

---
 documentation/leo/03_language.md  |  210 ++--
 documentation/leo/04_operators.md | 1613 +++++++++++++++--------------
 documentation/leo/08_resources.md |    4 +-
 3 files changed, 911 insertions(+), 916 deletions(-)

diff --git a/documentation/leo/03_language.md b/documentation/leo/03_language.md
index a9458a967..c9ed35f02 100644
--- a/documentation/leo/03_language.md
+++ b/documentation/leo/03_language.md
@@ -288,9 +288,9 @@ record token {
 
 ### Array
 
-Leo supports static arrays. Arrays are declared as `[type; length]` and can be nested. Arrays cannot be empty nor modified.
+Leo supports static arrays. Array types are declared as `[type; length]` and can be nested. Arrays cannot be empty nor modified.
 
-Arrays only support constant accesses (the index must be a constant value). The accessor value must be a constant integer.
+Arrays only support constant accesses. The accessor expression must be a constant integer.
 
 Arrays can contain primitive data types, structs, or arrays. Structs and records can also contain arrays.
 
@@ -300,14 +300,14 @@ Arrays can be iterated over using a for loop.
 // Initalize a boolean array of length 4
 let arr: [bool; 4] = [true, false, true, false];
 
-// Nested Array
+// Nested array
 let nested: [[bool; 2]; 2] = [[true, false], [true, false]];
 
-// Array of Structs
 struct bar {
     data: u8,
 }
 
+// Array of structs
 let arr_of_structs: [bar; 2] = [bar { data: 1u8 }, bar { data: 2u8 }];
 
 // Access the field of a struct within an array
@@ -326,7 +326,7 @@ record floo {
     data: [u8; 8],
 }
 
-// Declare a mapping that contains an array value
+// Declare a mapping that contains array values
 mapping data: address => [bool; 8];
 
 // Iterate over an array using a for loop and sum the values within
@@ -341,7 +341,7 @@ transition sum_with_loop(a: [u64; 4]) -> u64 {
 
 ### Tuple
 
-Leo supports tuples. Tuples are declared as `(type1, type2, ...)` and can be nested. Tuples cannot be empty nor modified.
+Leo supports tuples. Tuple types are declared as `(type1, type2, ...)` and can be nested. Tuples cannot be empty or modified.
 
 Tuples only support constant access with a dot `.` and a constant integer.
 
@@ -378,7 +378,7 @@ program hello.aleo {
 
 #### Function Inputs
 
-A function input is declared as `{visibility} {name}: {type},`
+A function input is declared as `{visibility} {name}: {type}`.
 Function inputs must be declared just after the function name declaration, in parentheses.
 
 ```leo showLineNumbers
@@ -401,11 +401,11 @@ transition foo(public a: field) -> field {
 
 ### Helper Function
 
-A helper function is declared as `function {name}() {}`.
+A helper function is declared as `function {name}({arguments}) {}`.
 Helper functions contain expressions and statements that can compute values,
 however helper functions cannot produce `records`.
 
-Helper functions cannot be called directly from the outside. Instead, they must be called by other functions.
+Helper functions cannot be called directly. Instead, they must be called by other functions.
 Inputs of helper functions cannot have `{visibility}` modifiers like transition functions,
 since they are used only internally, not as part of a program's external interface.
 
@@ -439,11 +439,11 @@ inline foo(
 
 The rules for functions (in the traditional sense) are as follows:
 
-- There are three variants of functions: transition, function, inline.
-- transitions can only call functions and inlines.
-- functions can only call inlines.
-- inlines can only call inlines.
-- Direct/indirect recursive calls are not allowed
+- There are three variants of functions: `transition`, `function`, `inline`.
+- A `transition` can only call a `function`, `inline`, or external `transition`.
+- A `function` can only call an `inline`.
+- An `inline` can only call another `inline`.
+- Direct/indirect recursive calls are not allowed.
 
 ### Async Function
 
@@ -463,9 +463,9 @@ program transfer.aleo {
     // from `account` into a token record for the specified receiver.
     //
     // This function preserves privacy for the receiver's record, however
-    // it publicly reveals the caller and the specified token amount.
+    // it publicly reveals the sender and the specified token amount.
     async transition transfer_public_to_private(
-        public receiver: address,
+        receiver: address,
         public amount: u64
     ) -> (token, Future) {
         // Produce a token record for the token receiver.
@@ -493,7 +493,7 @@ program transfer.aleo {
 
 If there is no need to create or alter the public on-chain state, async functions are not required.
 
-### Mapping
+### Mappings
 
 A mapping is declared as `mapping {name}: {key-type} => {value-type}`.
 Mappings contain key-value pairs.
@@ -508,8 +508,39 @@ mapping account: address => u64;
 
 #### Mapping Operations
 
-The mapping struct allows the programmer to apply updates to a program mapping data structure by calling one of the
-following functions.
+Mappings can be read from and modified by calling one of the following functions.
+
+
+
+#### get
+
+A get command, e.g. `current_value = Mapping::get(counter, addr);`
+Gets the value stored at `addr` in `counter` and stores the result in `current_value`
+If the value at `addr` does not exist, then the program will fail to execute.
+
+#### get_or_use
+
+A get command that uses the provided default if the key is not present in the mapping,  
+e.g. `let current_value: u64 = Mapping::get_or_use(counter, addr, 0u64);`  
+Gets the value stored at `addr` in `counter` and stores the result in `current_value`.
+If the key is not present, `0u64` is stored in `counter` (associated to the key) and in `current_value`.
+
+#### set
+
+A set command, e.g. `Mapping::set(counter, addr, current_value + 1u64);`
+Sets the `addr` entry as `current_value + 1u64` in `counter`.
+
+#### contains
+
+A contains command, e.g. `let contains: bool = Mapping::contains(counter, addr);`
+Returns `true` if `addr` is present in `counter`, `false` otherwise.
+
+#### remove
+
+A remove command, e.g. `Mapping::remove(counter, addr);`
+Removes the entry at `addr` in `counter`.
+
+#### Usage 
 
 :::info
 Mapping operations are only allowed in an [async function](#async-function).
@@ -532,42 +563,47 @@ program test.aleo {
 
 }
 ```
+## Control Structures
 
-#### get
-
-A get command, e.g. `current_value = Mapping::get(counter, addr);`
-Gets the value stored at `addr` in `counter` and stores the result in `current_value`
-If the value at `addr` does not exist, then the program will fail to execute.
-
-#### get_or_use
+### If Statements
 
-A get command that uses the provided default in case of failure,  
-e.g. `let current_value: u64 = Mapping::get_or_use(counter, addr, 0u64);`  
-Gets the value stored at `addr` in `counter` and stores the result in `current_value`.
-If the key is not present, `0u64` is stored in `counter` and stored in `current_value`.
+If statements are declared as `if {condition} { ... } else if {condition} { ... } else { ... }`.
+If statements can be nested.
 
-#### set
-
-A set command, e.g. `Mapping::set(counter, addr, current_value + 1u64);`
-Sets the `addr` entry as `current_value + 1u64` in `counter`.
+```leo
+    let a: u8 = 1u8;
+    
+    if a == 1u8 {
+        a += 1u8;
+    } else if a == 2u8 {
+        a += 2u8;
+    } else {
+        a += 3u8;
+    }
+```
 
-#### contains
+### Return Statements
 
-A contains command, e.g. `let contains: bool = Mapping::contains(counter, addr);`
-Returns `true` if `addr` is present in `counter`, `false` otherwise.
+Return statements are declared as `return {expression};`.
 
-#### remove
+```leo
+    let a: u8 = 1u8;
+    
+    if a == 1u8 {
+        return a + 1u8;
+    } else if a == 2u8 {
+        return a + 2u8;
+    } else {
+        return a + 3u8;
+    }
+```
 
-A remove command, e.g. `Mapping::remove(counter, addr);`
-Removes the entry at `addr` in `counter`.
 
-## For Loops
+### For Loops
 
-For Loops are declared as `for {variable: type} in {lower bound}..{upper bound}`. Unsigned integer
-types `u8`, `u16`, and `u32` are recommended for loop variable types. The lower bound must be
+For loops are declared as `for {variable: type} in {lower bound}..{upper bound}`. The loop bounds must be integer types and constant. Furthermore, the lower bound must be
 less than the upper bound. Nested loops are supported.
 
-### Example
 
 ```leo
   let count: u32 = 0u32;
@@ -582,13 +618,11 @@ less than the upper bound. Nested loops are supported.
 ## Operators
 
 Operators in Leo compute a value based off of one or more expressions.
-Leo will try to detect arithmetic operation errors as soon as possible.
-If an integer overflow or division by zero can be identified at compile time, Leo will quickly tell the programmer.
-Otherwise, the error will be caught at proving time when transition function inputs are processed.
+Leo defaults to checked arithmetic, which means that it will throw an error if an overflow or division by zero is detected.
 
 For instance, addition adds `first` with `second`, storing the outcome in `destination`.
 For integer types, a constraint is added to check for overflow.
-For cases where wrapping semantics are needed for integer types, see the `Add Wrapped` operator.
+For cases where wrapping semantics are needed for integer types, see the wrapped variants of the operators.
 
 ```leo
 let a: u8 = 1u8 + 1u8;
@@ -601,59 +635,7 @@ a = a.add(1u8);
 // a is now equal to 4
 ```
 
-### Arithmetic Operators
-
-|                                  Operation                                   |      Operands       |                                   Supported Types                                    |
-| :--------------------------------------------------------------------------: | :-----------------: | :----------------------------------------------------------------------------------: |
-|                                   addition                                   |  `+` `+=` `.add()`  | `field` `group` `scalar` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` |
-|                              wrapping addition                               |  `.add_wrapped()`   |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-|                               negation(unary)                                |    `-` `.neg()`     |                    `field` `group` `i8` `i16` `i32` `i64` `i128`                     |
-|                             subtraction(binary)                              |  `-` `-=` `.sub()`  |     `field` `group` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`      |
-|                         wrapping subtraction(binary)                         |  `.sub_wrapped()`   |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-|                                multiplication                                |  `*` `*=` `.mul()`  | `field` `group` `scalar` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` |
-|                           wrapping multiplication                            |  `.mul_wrapped()`   |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-|                                   division                                   |  `/` `/=` `.div()`  |         `field` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`          |
-|                              wrapping division                               |  `.div_wrapped()`   |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-|                                  remainder                                   |  `%` `%=` `.rem()`  |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-|                              wrapping remainder                              |  `.rem_wrapped()`   |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-|                                exponentiation                                | `**` `**=` `.pow()` |         `field` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`          |
-|                           wrapping exponentiation                            |  `.pow_wrapped()`   |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-|          [left shift](https://developer.aleo.org/leo/operators#shl)          | `<<` `<<=` `.shl()` |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-| [wrapping left shift](https://developer.aleo.org/leo/operators#shl_wrapped)  |  `.shl_wrapped()`   |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-|         [right shift](https://developer.aleo.org/leo/operators#shr)          | `>>` `>>=` `.shr()` |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-| [wrapping right shift](https://developer.aleo.org/leo/operators#shr_wrapped) |  `.shr_wrapped()`   |             `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128`              |
-|                                absolute value                                |      `.abs()`       |                            `i8` `i16` `i32` `i64` `i128`                             |
-|                           wrapping absolute value                            |  `.abs_wrapped()`   |                            `i8` `i16` `i32` `i64` `i128`                             |
-|                                   doubling                                   |     `.double()`     |                                   `field` `group`                                    |
-|                                   squaring                                   |     `.square()`     |                                       `field`                                        |
-|                                 square root                                  |  `.square_root()`   |                                       `field`                                        |
-|                                   inverse                                    |  `.square_root()`   |                                       `field`                                        |
-
-### Logical Operators
-
-|    Operation    |                     Operands                     |                          Supported Types                           |
-| :-------------: | :----------------------------------------------: | :----------------------------------------------------------------: |
-|       NOT       |                   `!` `.not()`                   | `bool` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` |
-|       AND       |                `&` `&=` `.and()`                 | `bool` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` |
-|       OR        | <code>&#124;</code> <code>&#124;=</code> `.or()` | `bool` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` |
-|       XOR       |                `^` `^=` `.xor()`                 | `bool` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` |
-|      NAND       |                    `.nand()`                     |                               `bool`                               |
-|       NOR       |                     `.nor()`                     |                               `bool`                               |
-| conditional AND |                       `&&`                       |                               `bool`                               |
-| conditional OR  |            <code>&#124;&#124;</code>             |                               `bool`                               |
-
-### Relational Operators
-
-Relational operators will always resolve to a boolean `bool` value.
-
-|       Operation       |   Operands    |                         Supported Types                         |
-| :-------------------: | :-----------: | :-------------------------------------------------------------: |
-|         equal         | `==` `.eq()`  | `bool`, `group`, `field`, integers, addresses, structs, records |
-|       not-equal       | `!=` `.neq()` | `bool`, `group`, `field`, integers, addresses, structs, records |
-|       less than       |  `<` `.lt()`  |                   `field`, `scalar`, integers                   |
-|  less than or equal   | `<=` `.lte()` |                   `field`, `scalar`, integers                   |
-|     greater than      |  `>` `.gt()`  |                   `field`, `scalar`, integers                   |
-| greater than or equal | `>=` `.gte()` |                   `field`, `scalar`, integers                   |
+See the [Operator Reference](./04_operators.md) for a complete list of operators.
 
 ### Operator Precedence
 
@@ -685,17 +667,13 @@ let result = (a + 1u8) * 2u8;
 
 `(a + 1u8)` will be evaluated before multiplying by two `* 2u8`.
 
-## Commands
+## Context-dependent Expressions
 
-Leo supports several commands that can be used to reference information about the Aleo blockchain and the current transaction.
+Leo supports several expressions that can be used to reference information about the Aleo blockchain and the current transaction.
 
 ### self.caller
 
-:::note
-`self.caller` is currently implemented as `self.signer` within Aleo instructions. This will be fixed in a upcoming release.
-:::
-
-Returns the address of the account that is calling the program function.
+Returns the address of the account/program that invoked the current `transition`.
 
 ```leo showLineNumbers
 program test.aleo {
@@ -705,6 +683,18 @@ program test.aleo {
 }
 ```
 
+### self.signer
+
+Returns the address of the account that invoked that top-level `transition`. This is the account that signed the transaction.
+
+```leo showLineNumbers
+program test.aleo {
+    transition matches(addr: address) -> bool {
+        return self.signer == addr;
+    }
+}
+```
+
 ### block.height
 
 Returns the height of the current block.
@@ -728,7 +718,7 @@ program test.aleo {
 ## Core Functions
 
 Core functions are functions that are built into the Leo language.
-They are used to perform cryptographic operations such as hashing, commitment, and random number generation.
+They are used to check assertions and perform cryptographic operations such as hashing, commitment, and random number generation.
 
 ### Assert and AssertEq
 
@@ -747,7 +737,7 @@ program test.aleo {
 ### Hash
 
 Leo supports the following hashing algorithms: `BHP256`, `BHP512`, `BHP768`, `BHP1024`, `Pedersen64`, `Pedersen128`, `Poseidon2`, `Poseidon4`, `Poseidon8`, `Keccak256`, `Keccak384`, `Keccak512`, `SHA3_256`, `SHA3_384`, `SHA3_512`.  
-The output type of a commitment function is specified in the function name. e.g. `hash_to_group` will return a `group` type.
+The output type of a hash function is specified in the function name. e.g. `hash_to_group` will return a `group` type.
 Hash functions take any type as an argument.
 
 ```leo showLineNumbers
diff --git a/documentation/leo/04_operators.md b/documentation/leo/04_operators.md
index 290e343ce..8aba2936f 100644
--- a/documentation/leo/04_operators.md
+++ b/documentation/leo/04_operators.md
@@ -10,47 +10,47 @@ The Leo operators compile down to [Aleo instructions opcodes](../aleo/04_opcodes
 ## Table of Standard Operators
 | Name                        | Description                         |
 |-----------------------------|:------------------------------------|
-| [abs](#abs)                 | Absolute value operation            |
-| [abs_wrapped](#abs_wrapped) | Wrapping absolute value operation   |
-| [add](#add)                 | Addition operation                  |
-| [add_wrapped](#add_wrapped) | Wrapping addition operation         |
-| [and](#and)                 | AND operation                       |
+| [abs](#abs)                 | Absolute value                      |
+| [abs_wrapped](#abs_wrapped) | Wrapping absolute value             |
+| [add](#add)                 | Addition                            |
+| [add_wrapped](#add_wrapped) | Wrapping addition                   |
+| [and](#and)                 | Conjunction                         |
 | [assert](#assert)           | Assert boolean true                 |
 | [assert_eq](#assert_eq)     | Assert equality                     |
 | [assert_neq](#assert_neq)   | Assert non-equality                 |
-| [div](#div)                 | Division operation                  |
+| [div](#div)                 | Division                            |
 | [div_wrapped](#div_wrapped) | Wrapping division operation         |
-| [double](#double)           | Double operation                    |
-| [group::GEN](#groupgen)     | Group generator                     |
+| [double](#double)           | Double                              |
+| [group::GEN](#groupgen)     | group generator                     |
 | [gt](#gt)                   | Greater than comparison             |
 | [gte](#gte)                 | Greater than or equal to comparison |
-| [inv](#inv)                 | Multiplicative inverse operation    |
+| [inv](#inv)                 | Multiplicative inverse              |
 | [eq](#eq)                   | Equality comparison                 |
-| [neq](#neq)                 | Not equal comparison                |
+| [neq](#neq)                 | Non-equality comparison             |
 | [lt](#lt)                   | Less than comparison                |
 | [lte](#lte)                 | Less than or equal to comparison    |
-| [mod](#mod)                 | Arithmetic modulo operation         |
-| [mul](#mul)                 | Multiplication operation            |
-| [mul_wrapped](#mul_wrapped) | Wrapping multiplication operation   |
-| [nand](#nand)               | `Boolean` NAND operation            |
-| [neg](#neg)                 | Additive inverse operation          |
-| [nor](#nor)                 | `Boolean` NOR operation             |
-| [not](#not)                 | NOT operation                       |
-| [or](#or)                   | OR Operation                        |
-| [pow](#pow)                 | Exponentiation operation            |
-| [pow_wrapped](#pow_wrapped) | Wrapping exponentiation operation   |
-| [rem](#rem)                 | Remainder operation                 |
-| [rem_wrapped](#rem_wrapped) | Wrapping remainder operation        |
-| [shl](#shl)                 | Shift left operation                |
-| [shl_wrapped](#shl_wrapped) | Wrapping shift left operation       |
-| [shr](#shr)                 | Shift right operation               |
-| [shr_wrapped](#shr_wrapped) | Wrapping shift right operation      |
-| [square_root](#square_root) | Square root operation               |
-| [square](#square)           | Square operation                    |
-| [sub](#sub)                 | Subtraction operation               |
-| [sub_wrapped](#sub_wrapped) | Wrapping subtraction operation      |
-| [ternary](#ternary)         | Ternary select operation            |
-| [xor](#xor)                 | XOR operation                       |
+| [mod](#mod)                 | Modulo                              |
+| [mul](#mul)                 | Multiplication                      |
+| [mul_wrapped](#mul_wrapped) | Wrapping multiplication             |
+| [nand](#nand)               | Negated conjunction                 |
+| [neg](#neg)                 | Additive inverse                    |
+| [nor](#nor)                 | Negated disjunction                 |
+| [not](#not)                 | Logical negation                    |
+| [or](#or)                   | (Inclusive) disjunction             |
+| [pow](#pow)                 | Exponentiation                      |
+| [pow_wrapped](#pow_wrapped) | Wrapping exponentiation             |
+| [rem](#rem)                 | Remainder                           |
+| [rem_wrapped](#rem_wrapped) | Wrapping remainder                  |
+| [shl](#shl)                 | Shift left                          |
+| [shl_wrapped](#shl_wrapped) | Wrapping shift left                 |
+| [shr](#shr)                 | Shift right                         |
+| [shr_wrapped](#shr_wrapped) | Wrapping shift right                |
+| [square_root](#square_root) | Square root                         |
+| [square](#square)           | Square                              |
+| [sub](#sub)                 | Subtraction                         |
+| [sub_wrapped](#sub_wrapped) | Wrapping subtraction                |
+| [ternary](#ternary)         | Ternary select                      |
+| [xor](#xor)                 | Exclusive conjunction               |
 
 ## Table of Cryptographic Operators
 | Name                                                                    | Description                       |
@@ -94,17 +94,17 @@ let b: i8 = a.abs(); // 1i8
 
 Computes the absolute value of the input, checking for overflow, storing the result in the destination.
 
-For integer types, a constraint is added to check for underflow. For cases where wrapping semantics are needed, see the [abs_wrapped](#abs_wrapped) instruction. This underflow happens when the input is the minimum value of a signed integer type. For example, `abs -128i8` would result in underflow, since `128` cannot be represented as an `i8`.
+Note that execution will halt if the operation overflows/underflows. For cases where wrapping semantics are needed, see the [abs_wrapped](#abs_wrapped) instruction. This underflow happens when the input is the minimum value of a signed integer type. For example, `abs -128i8` would result in underflow, since `128` cannot be represented as an `i8`.
 
 #### Supported Types
 
 | Input  | Destination |
 |--------|:------------|
-| `I8`   | `I8`        |
-| `I16`  | `I16`       |
-| `I32`  | `I32`       |
-| `I64`  | `I64`       |
-| `I128` | `I128`      |
+| `i8`   | `i8`        |
+| `i16`  | `i16`       |
+| `i32`  | `i32`       |
+| `i64`  | `i64`       |
+| `i128` | `i128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -124,11 +124,11 @@ Compute the absolute value of the input, wrapping around at the boundary of the
 
 | Input  | Destination |
 |--------|:------------|
-| `I8`   | `I8`        |
-| `I16`  | `I16`       |
-| `I32`  | `I32`       |
-| `I64`  | `I64`       |
-| `I128` | `I128`      |
+| `i8`   | `i8`        |
+| `i16`  | `i16`       |
+| `i32`  | `i32`       |
+| `i64`  | `i64`       |
+| `i128` | `i128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -143,27 +143,27 @@ let c: u8 = b.add(1u8); // 3u8
 
 #### Description
 
-Adds `first` with `second`, storing the outcome in `destination`.
+Adds `first` with `second`, storing the result in `destination`.
 
-For integer types, a constraint is added to check for overflow. For cases where wrapping semantics are needed for integer types, see the [add_wrapped](#add_wrapped) instruction.
+Note that execution will halt if the operation overflows. For cases where wrapping semantics are needed for integer types, see the [add_wrapped](#add_wrapped) instruction.
 
 #### Supported Types
 
 | First    | Second   | Destination |
 |----------|----------|-------------|
-| `Field`  | `Field`  | `Field`     |
-| `Group`  | `Group`  | `Group`     |
-| `I8`     | `I8`     | `I8`        |
-| `I16`    | `I16`    | `I16`       |
-| `I32`    | `I32`    | `I32`       |
-| `I64`    | `I64`    | `I64`       |
-| `I128`   | `I128`   | `I128`      |
-| `U8`     | `U8`     | `U8`        |
-| `U16`    | `U16`    | `U16`       |
-| `U32`    | `U32`    | `U32`       |
-| `U64`    | `U64`    | `U64`       |
-| `U128`   | `U128`   | `U128`      |
-| `Scalar` | `Scalar` | `Scalar`    |
+| `field`  | `field`  | `field`     |
+| `group`  | `group`  | `group`     |
+| `i8`     | `i8`     | `i8`        |
+| `i16`    | `i16`    | `i16`       |
+| `i32`    | `i32`    | `i32`       |
+| `i64`    | `i64`    | `i64`       |
+| `i128`   | `i128`   | `i128`      |
+| `u8`     | `u8`     | `u8`        |
+| `u16`    | `u16`    | `u16`       |
+| `u32`    | `u32`    | `u32`       |
+| `u64`    | `u64`    | `u64`       |
+| `u128`   | `u128`   | `u128`      |
+| `scalar` | `scalar` | `scalar`    |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -177,22 +177,22 @@ let b: u8 = a.add_wrapped(1u8); // 0u8
 
 #### Description
 
-Adds `first` with `second`, wrapping around at the boundary of the type, and storing the outcome in `destination`.
+Adds `first` with `second`, wrapping around at the boundary of the type, and storing the result in `destination`.
 
 #### Supported Types
 
 | First  | Second | Destination |
 |--------|--------|:------------|
-| `I8`   | `I8`   | `I8`        |
-| `I16`  | `I16`  | `I16`       |
-| `I32`  | `I32`  | `I32`       |
-| `I64`  | `I64`  | `I64`       |
-| `I128` | `I128` | `I128`      |
-| `U8`   | `U8`   | `U8`        |
-| `U16`  | `U16`  | `U16`       |
-| `U32`  | `U32`  | `U32`       |
-| `U64`  | `U64`  | `U64`       |
-| `U128` | `U128` | `U128`      |
+| `i8`   | `i8`   | `i8`        |
+| `i16`  | `i16`  | `i16`       |
+| `i32`  | `i32`  | `i32`       |
+| `i64`  | `i64`  | `i64`       |
+| `i128` | `i128` | `i128`      |
+| `u8`   | `u8`   | `u8`        |
+| `u16`  | `u16`  | `u16`       |
+| `u32`  | `u32`  | `u32`       |
+| `u64`  | `u64`  | `u64`       |
+| `u128` | `u128` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -208,23 +208,23 @@ let b: i8 = 1i8.and(2i8); // 0i8
 #### Description
 
 Performs an AND operation on integer (bitwise) or boolean `first` and `second`,
-storing the outcome in `destination`.
+storing the result in `destination`.
 
 #### Supported Types
 
-| First     | Second    | Destination |
-|-----------|-----------|:------------|
-| `Boolean` | `Boolean` | `Boolean`   |
-| `I8`      | `I8`      | `I8`        |
-| `I16`     | `I16`     | `I16`       |
-| `I32`     | `I32`     | `I32`       |
-| `I64`     | `I64`     | `I64`       |
-| `I128`    | `I128`    | `I128`      |
-| `U8`      | `U8`      | `U8`        |
-| `U16`     | `U16`     | `U16`       |
-| `U32`     | `U32`     | `U32`       |
-| `U64`     | `U64`     | `U64`       |
-| `U128`    | `U128`    | `U128`      |
+| First     | Second   | Destination |
+|-----------|----------|:------------|
+| `bool`    | `bool`   | `bool`      |
+| `i8`      | `i8`     | `i8`        |
+| `i16`     | `i16`    | `i16`       |
+| `i32`     | `i32`    | `i32`       |
+| `i64`     | `i64`    | `i64`       |
+| `i128`    | `i128`   | `i128`      |
+| `u8`      | `u8`     | `u8`        |
+| `u16`     | `u16`    | `u16`       |
+| `u32`     | `u32`    | `u32`       |
+| `u64`     | `u64`    | `u64`       |
+| `u128`    | `u128`   | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -247,7 +247,7 @@ Checks whether the expression evaluates to a `true` boolean value, halting if ev
 
 | Expression |
 |------------|
-| `Boolean`  |
+| `bool`  |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -270,23 +270,23 @@ Checks whether `first` and `second` are equal, halting if they are not equal.
 
 | First       | Second      |
 |-------------|-------------|
-| `Address`   | `Address`   |
-| `Boolean`   | `Boolean`   |
-| `Field`     | `Field`     |
-| `Group`     | `Group`     |
-| `I8`        | `I8`        |
-| `I16`       | `I16`       |
-| `I32`       | `I32`       |
-| `I64`       | `I64`       |
-| `I128`      | `I128`      |
-| `U8`        | `U8`        |
-| `U16`       | `U16`       |
-| `U32`       | `U32`       |
-| `U64`       | `U64`       |
-| `U128`      | `U128`      |
-| `Scalar`    | `Scalar`    |
+| `address`   | `address`   |
+| `bool`   | `bool`   |
+| `field`     | `field`     |
+| `group`     | `group`     |
+| `i8`        | `i8`        |
+| `i16`       | `i16`       |
+| `i32`       | `i32`       |
+| `i64`       | `i64`       |
+| `i128`      | `i128`      |
+| `u8`        | `u8`        |
+| `u16`       | `u16`       |
+| `u32`       | `u32`       |
+| `u64`       | `u64`       |
+| `u128`      | `u128`      |
+| `scalar`    | `scalar`    |
 | `Signature` | `Signature` |
-| `Struct`    | `Struct`    |
+| `struct`    | `struct`    |
 | `Record`    | `Record`    |
 
 [Back to Top](#table-of-standard-operators)
@@ -310,23 +310,23 @@ Checks whether `first` and `second` are not equal, halting if they are equal.
 
 | First       | Second      |
 |-------------|-------------|
-| `Address`   | `Address`   |
-| `Boolean`   | `Boolean`   |
-| `Field`     | `Field`     |
-| `Group`     | `Group`     |
-| `I8`        | `I8`        |
-| `I16`       | `I16`       |
-| `I32`       | `I32`       |
-| `I64`       | `I64`       |
-| `I128`      | `I128`      |
-| `U8`        | `U8`        |
-| `U16`       | `U16`       |
-| `U32`       | `U32`       |
-| `U64`       | `U64`       |
-| `U128`      | `U128`      |
-| `Scalar`    | `Scalar`    |
+| `address`   | `address`   |
+| `bool`   | `bool`   |
+| `field`     | `field`     |
+| `group`     | `group`     |
+| `i8`        | `i8`        |
+| `i16`       | `i16`       |
+| `i32`       | `i32`       |
+| `i64`       | `i64`       |
+| `i128`      | `i128`      |
+| `u8`        | `u8`        |
+| `u16`       | `u16`       |
+| `u32`       | `u32`       |
+| `u64`       | `u64`       |
+| `u128`      | `u128`      |
+| `scalar`    | `scalar`    |
 | `Signature` | `Signature` |
-| `Struct`    | `Struct`    |
+| `struct`    | `struct`    |
 | `Record`    | `Record`    |
 
 [Back to Top](#table-of-standard-operators)
@@ -368,12 +368,12 @@ let c: u8 = b.div(2u8); // 1u8
 
 Performs division of the first operand by the second, storing the result in the destination. The operation halts if division by zero is attempted.
 
-For integer types, this operation performs truncated division. Truncated division rounds towards zero, regardless of the sign of the operands. This means it cuts off any digits after the decimal, leaving the largest whole number less than or equal to the result.
+For integer types, this operation performs truncated division. Truncated division rounds towards zero, regardless of the sign of the operands. This means it cuts off any digits after the decimal, leaving the whole number whose absolute value is less than or equal to the result.
 
 For example:
 
-1. `7 / 3` yields `2`, not `2.3333`.
-2. `-7 / 3` yields `-2`, not `-2.3333`.
+- `7 / 3` yields `2`, not `2.3333`.
+- `-7 / 3` yields `-2`, not `-2.3333`.
 
 The operation halts if there is an underflow. Underflow occurs when dividing the minimum value of a signed integer type by -1. For example, `-128i8 / -1i8` would result in underflow, since 128 cannot be represented as an `i8`.
 
@@ -385,17 +385,17 @@ For cases where wrapping semantics are needed for integer types, see the [div_wr
 
 | First   | Second  | Destination |
 |---------|---------|:------------|
-| `Field` | `Field` | `Field`     |
-| `I8`    | `I8`    | `I8`        |
-| `I16`   | `I16`   | `I16`       |
-| `I32`   | `I32`   | `I32`       |
-| `I64`   | `I64`   | `I64`       |
-| `I128`  | `I128`  | `I128`      |
-| `U8`    | `U8`    | `U8`        |
-| `U16`   | `U16`   | `U16`       |
-| `U32`   | `U32`   | `U32`       |
-| `U64`   | `U64`   | `U64`       |
-| `U128`  | `U128`  | `U128`      |
+| `field` | `field` | `field`     |
+| `i8`    | `i8`    | `i8`        |
+| `i16`   | `i16`   | `i16`       |
+| `i32`   | `i32`   | `i32`       |
+| `i64`   | `i64`   | `i64`       |
+| `i128`  | `i128`  | `i128`      |
+| `u8`    | `u8`    | `u8`        |
+| `u16`   | `u16`   | `u16`       |
+| `u32`   | `u32`   | `u32`       |
+| `u64`   | `u64`   | `u64`       |
+| `u128`  | `u128`  | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -409,22 +409,22 @@ let b: i8 = a.div_wrapped(-1i8); // -128i8
 
 #### Description
 
-Divides `first` by `second`, wrapping around at the boundary of the type, and storing the outcome in `destination`.
+Divides `first` by `second`, wrapping around at the boundary of the type, and storing the result in `destination`.
 
 #### Supported Types
 
 | First  | Second | Destination |
 |--------|--------|:------------|
-| `I8`   | `I8`   | `I8`        |
-| `I16`  | `I16`  | `I16`       |
-| `I32`  | `I32`  | `I32`       |
-| `I64`  | `I64`  | `I64`       |
-| `I128` | `I128` | `I128`      |
-| `U8`   | `U8`   | `U8`        |
-| `U16`  | `U16`  | `U16`       |
-| `U32`  | `U32`  | `U32`       |
-| `U64`  | `U64`  | `U64`       |
-| `U128` | `U128` | `U128`      |
+| `i8`   | `i8`   | `i8`        |
+| `i16`  | `i16`  | `i16`       |
+| `i32`  | `i32`  | `i32`       |
+| `i64`  | `i64`  | `i64`       |
+| `i128` | `i128` | `i128`      |
+| `u8`   | `u8`   | `u8`        |
+| `u16`  | `u16`  | `u16`       |
+| `u32`  | `u32`  | `u32`       |
+| `u64`  | `u64`  | `u64`       |
+| `u128` | `u128` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -438,15 +438,15 @@ let b: group = a.double();
 
 #### Description
 
-Doubles the input, storing the outcome in `destination`.
+Doubles the input, storing the result in `destination`.
 
 
 #### Supported Types
 
 | Input   | Destination |
 |---------|-------------|
-| `Field` | `Field`     |
-| `Group` | `Group`     |
+| `field` | `field`     |
+| `group` | `group`     |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -466,18 +466,18 @@ Checks if `first` is greater than `second`, storing the result in `destination`.
 
 | First    | Second   | Destination |
 |----------|----------|-------------|
-| `Field`  | `Field`  | `Boolean`   |
-| `I8`     | `I8`     | `Boolean`   |
-| `I16`    | `I16`    | `Boolean`   |
-| `I32`    | `I32`    | `Boolean`   |
-| `I64`    | `I64`    | `Boolean`   |
-| `I128`   | `I128`   | `Boolean`   |
-| `U8`     | `U8`     | `Boolean`   |
-| `U16`    | `U16`    | `Boolean`   |
-| `U32`    | `U32`    | `Boolean`   |
-| `U64`    | `U64`    | `Boolean`   |
-| `U128`   | `U128`   | `Boolean`   |
-| `Scalar` | `Scalar` | `Boolean`   |
+| `field`  | `field`  | `bool`   |
+| `i8`     | `i8`     | `bool`   |
+| `i16`    | `i16`    | `bool`   |
+| `i32`    | `i32`    | `bool`   |
+| `i64`    | `i64`    | `bool`   |
+| `i128`   | `i128`   | `bool`   |
+| `u8`     | `u8`     | `bool`   |
+| `u16`    | `u16`    | `bool`   |
+| `u32`    | `u32`    | `bool`   |
+| `u64`    | `u64`    | `bool`   |
+| `u128`   | `u128`   | `bool`   |
+| `scalar` | `scalar` | `bool`   |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -497,18 +497,18 @@ Checks if `first` is greater than or equal to `second`, storing the result in `d
 
 | First    | Second   | Destination |
 |----------|----------|-------------|
-| `Field`  | `Field`  | `Boolean`   |
-| `I8`     | `I8`     | `Boolean`   |
-| `I16`    | `I16`    | `Boolean`   |
-| `I32`    | `I32`    | `Boolean`   |
-| `I64`    | `I64`    | `Boolean`   |
-| `I128`   | `I128`   | `Boolean`   |
-| `U8`     | `U8`     | `Boolean`   |
-| `U16`    | `U16`    | `Boolean`   |
-| `U32`    | `U32`    | `Boolean`   |
-| `U64`    | `U64`    | `Boolean`   |
-| `U128`   | `U128`   | `Boolean`   |
-| `Scalar` | `Scalar` | `Boolean`   |
+| `field`  | `field`  | `bool`   |
+| `i8`     | `i8`     | `bool`   |
+| `i16`    | `i16`    | `bool`   |
+| `i32`    | `i32`    | `bool`   |
+| `i64`    | `i64`    | `bool`   |
+| `i128`   | `i128`   | `bool`   |
+| `u8`     | `u8`     | `bool`   |
+| `u16`    | `u16`    | `bool`   |
+| `u32`    | `u32`    | `bool`   |
+| `u64`    | `u64`    | `bool`   |
+| `u128`   | `u128`   | `bool`   |
+| `scalar` | `scalar` | `bool`   |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -521,13 +521,13 @@ let a: field = 1field.inv();
 
 #### Description
 
-Computes the multiplicative inverse of the input, storing the outcome in `destination`.
+Computes the multiplicative inverse of the input, storing the result in `destination`.
 
 #### Supported Types
 
 | Input   | Destination |
 |---------|-------------|
-| `Field` | `Field`     |
+| `field` | `field`     |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -541,30 +541,30 @@ let b: bool = 1u8.eq(2u8); // false
 
 #### Description
 
-Compares `first` and `second`, storing the result in `destination`.
+Compares `first` and `second` for equality, storing the result in `destination`.
 
 #### Supported Types
 
 | First       | Second      | Destination |
 |-------------|-------------|-------------|
-| `Address`   | `Address`   | `Boolean`   |
-| `Boolean`   | `Boolean`   | `Boolean`   |
-| `Field`     | `Field`     | `Boolean`   |
-| `Group`     | `Group`     | `Boolean`   |
-| `I8`        | `I8`        | `Boolean`   |
-| `I16`       | `I16`       | `Boolean`   |
-| `I32`       | `I32`       | `Boolean`   |
-| `I64`       | `I64`       | `Boolean`   |
-| `I128`      | `I128`      | `Boolean`   |
-| `U8`        | `U8`        | `Boolean`   |
-| `U16`       | `U16`       | `Boolean`   |
-| `U32`       | `U32`       | `Boolean`   |
-| `U64`       | `U64`       | `Boolean`   |
-| `U128`      | `U128`      | `Boolean`   |
-| `Scalar`    | `Scalar`    | `Boolean`   |
-| `Signature` | `Signature` | `Boolean`   |
-| `Struct`    | `Struct`    | `Boolean`   |
-| `Record`    | `Record`    | `Boolean`   |
+| `address`   | `address`   | `bool`   |
+| `bool`   | `bool`   | `bool`   |
+| `field`     | `field`     | `bool`   |
+| `group`     | `group`     | `bool`   |
+| `i8`        | `i8`        | `bool`   |
+| `i16`       | `i16`       | `bool`   |
+| `i32`       | `i32`       | `bool`   |
+| `i64`       | `i64`       | `bool`   |
+| `i128`      | `i128`      | `bool`   |
+| `u8`        | `u8`        | `bool`   |
+| `u16`       | `u16`       | `bool`   |
+| `u32`       | `u32`       | `bool`   |
+| `u64`       | `u64`       | `bool`   |
+| `u128`      | `u128`      | `bool`   |
+| `scalar`    | `scalar`    | `bool`   |
+| `Signature` | `Signature` | `bool`   |
+| `struct`    | `struct`    | `bool`   |
+| `Record`    | `Record`    | `bool`   |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -578,30 +578,30 @@ let b: bool = 1u8.neq(2u8); // true
 
 #### Description
 
-Returns true if `first` is not equal to `second`, storing the result in `destination`.
+Compares `first` and `second` for non-equality, storing the result in `destination`.
 
 #### Supported Types
 
 | First       | Second      | Destination |
 |-------------|-------------|-------------|
-| `Address`   | `Address`   | `Boolean`   |
-| `Boolean`   | `Boolean`   | `Boolean`   |
-| `Field`     | `Field`     | `Boolean`   |
-| `Group`     | `Group`     | `Boolean`   |
-| `I8`        | `I8`        | `Boolean`   |
-| `I16`       | `I16`       | `Boolean`   |
-| `I32`       | `I32`       | `Boolean`   |
-| `I64`       | `I64`       | `Boolean`   |
-| `I128`      | `I128`      | `Boolean`   |
-| `U8`        | `U8`        | `Boolean`   |
-| `U16`       | `U16`       | `Boolean`   |
-| `U32`       | `U32`       | `Boolean`   |
-| `U64`       | `U64`       | `Boolean`   |
-| `U128`      | `U128`      | `Boolean`   |
-| `Scalar`    | `Scalar`    | `Boolean`   |
-| `Signature` | `Signature` | `Boolean`   |
-| `Struct`    | `Struct`    | `Boolean`   |
-| `Record`    | `Record`    | `Boolean`   |
+| `address`   | `address`   | `bool`   |
+| `bool`   | `bool`   | `bool`   |
+| `field`     | `field`     | `bool`   |
+| `group`     | `group`     | `bool`   |
+| `i8`        | `i8`        | `bool`   |
+| `i16`       | `i16`       | `bool`   |
+| `i32`       | `i32`       | `bool`   |
+| `i64`       | `i64`       | `bool`   |
+| `i128`      | `i128`      | `bool`   |
+| `u8`        | `u8`        | `bool`   |
+| `u16`       | `u16`       | `bool`   |
+| `u32`       | `u32`       | `bool`   |
+| `u64`       | `u64`       | `bool`   |
+| `u128`      | `u128`      | `bool`   |
+| `scalar`    | `scalar`    | `bool`   |
+| `Signature` | `Signature` | `bool`   |
+| `struct`    | `struct`    | `bool`   |
+| `Record`    | `Record`    | `bool`   |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -615,24 +615,24 @@ let b: bool = 1u8.lt(1u8); // false
 
 #### Description
 
-Checks if `first` is less than `second`, storing the outcome in `destination`.
+Checks if `first` is less than `second`, storing the result in `destination`.
 
 #### Supported Types
 
 | First    | Second   | Destination |
 |----------|----------|-------------|
-| `Field`  | `Field`  | `Boolean`   |
-| `I8`     | `I8`     | `Boolean`   |
-| `I16`    | `I16`    | `Boolean`   |
-| `I32`    | `I32`    | `Boolean`   |
-| `I64`    | `I64`    | `Boolean`   |
-| `I128`   | `I128`   | `Boolean`   |
-| `U8`     | `U8`     | `Boolean`   |
-| `U16`    | `U16`    | `Boolean`   |
-| `U32`    | `U32`    | `Boolean`   |
-| `U64`    | `U64`    | `Boolean`   |
-| `U128`   | `U128`   | `Boolean`   |
-| `Scalar` | `Scalar` | `Boolean`   |
+| `field`  | `field`  | `bool`   |
+| `i8`     | `i8`     | `bool`   |
+| `i16`    | `i16`    | `bool`   |
+| `i32`    | `i32`    | `bool`   |
+| `i64`    | `i64`    | `bool`   |
+| `i128`   | `i128`   | `bool`   |
+| `u8`     | `u8`     | `bool`   |
+| `u16`    | `u16`    | `bool`   |
+| `u32`    | `u32`    | `bool`   |
+| `u64`    | `u64`    | `bool`   |
+| `u128`   | `u128`   | `bool`   |
+| `scalar` | `scalar` | `bool`   |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -646,24 +646,24 @@ let b: bool = 1u8.lte(1u8); // true
 
 #### Description
 
-Checks if `first` is less than or equal to `second`, storing the outcome in `destination`.
+Checks if `first` is less than or equal to `second`, storing the result in `destination`.
 
 #### Supported Types
 
 | First    | Second   | Destination |
 |----------|----------|-------------|
-| `Field`  | `Field`  | `Boolean`   |
-| `I8`     | `I8`     | `Boolean`   |
-| `I16`    | `I16`    | `Boolean`   |
-| `I32`    | `I32`    | `Boolean`   |
-| `I64`    | `I64`    | `Boolean`   |
-| `I128`   | `I128`   | `Boolean`   |
-| `U8`     | `U8`     | `Boolean`   |
-| `U16`    | `U16`    | `Boolean`   |
-| `U32`    | `U32`    | `Boolean`   |
-| `U64`    | `U64`    | `Boolean`   |
-| `U128`   | `U128`   | `Boolean`   |
-| `Scalar` | `Scalar` | `Boolean`   |
+| `field`  | `field`  | `bool`   |
+| `i8`     | `i8`     | `bool`   |
+| `i16`    | `i16`    | `bool`   |
+| `i32`    | `i32`    | `bool`   |
+| `i64`    | `i64`    | `bool`   |
+| `i128`   | `i128`   | `bool`   |
+| `u8`     | `u8`     | `bool`   |
+| `u16`    | `u16`    | `bool`   |
+| `u32`    | `u32`    | `bool`   |
+| `u64`    | `u64`    | `bool`   |
+| `u128`   | `u128`   | `bool`   |
+| `scalar` | `scalar` | `bool`   |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -676,7 +676,7 @@ let a: u8 = 3u8.mod(2u8); // 1u8
 
 #### Description
 
-Takes the modulus of `first` with respect to `second`, storing the outcome in `destination`. Halts if `second` is zero.
+Takes the modulo of `first` with respect to `second`, storing the result in `destination`. Halts if `second` is zero.
 
 The semantics of this operation are consistent with the mathematical definition of modulo operation.
 
@@ -684,11 +684,11 @@ The semantics of this operation are consistent with the mathematical definition
 
 | First  | Second | Destination |
 |--------|--------|-------------|
-| `U8`   | `U8`   | `U8`        |
-| `U16`  | `U16`  | `U16`       |
-| `U32`  | `U32`  | `U32`       |
-| `U64`  | `U64`  | `U64`       |
-| `U128` | `U128` | `U128`      |
+| `u8`   | `u8`   | `u8`        |
+| `u16`  | `u16`  | `u16`       |
+| `u32`  | `u32`  | `u32`       |
+| `u64`  | `u64`  | `u64`       |
+| `u128` | `u128` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -702,27 +702,27 @@ let b: u8 = a.mul(2u8); // 8u8
 
 #### Description
 
-Multiplies `first` with `second`, storing the outcome in `destination`.
+Multiplies `first` with `second`, storing the result in `destination`.
 
-For integer types, a constraint is added to check for overflow/underflow. For cases where wrapping semantics are needed for integer types, see the [mul_wrapped](#mul_wrapped) instruction.
+Note that execution will halt if the operation overflows/underflows. For cases where wrapping semantics are needed for integer types, see the [mul_wrapped](#mul_wrapped) instruction.
 
 #### Supported Types
 
 | First    | Second   | Destination |
 |----------|----------|-------------|
-| `Field`  | `Field`  | `Field`     |
-| `Group`  | `Scalar` | `Group`     |
-| `Scalar` | `Group`  | `Group`     |
-| `I8`     | `I8`     | `I8`        |
-| `I16`    | `I16`    | `I16`       |
-| `I32`    | `I32`    | `I32`       |
-| `I64`    | `I64`    | `I64`       |
-| `I128`   | `I128`   | `I128`      |
-| `U8`     | `U8`     | `U8`        |
-| `U16`    | `U16`    | `U16`       |
-| `U32`    | `U32`    | `U32`       |
-| `U64`    | `U64`    | `U64`       |
-| `U128`   | `U128`   | `U128`      |
+| `field`  | `field`  | `field`     |
+| `group`  | `scalar` | `group`     |
+| `scalar` | `group`  | `group`     |
+| `i8`     | `i8`     | `i8`        |
+| `i16`    | `i16`    | `i16`       |
+| `i32`    | `i32`    | `i32`       |
+| `i64`    | `i64`    | `i64`       |
+| `i128`   | `i128`   | `i128`      |
+| `u8`     | `u8`     | `u8`        |
+| `u16`    | `u16`    | `u16`       |
+| `u32`    | `u32`    | `u32`       |
+| `u64`    | `u64`    | `u64`       |
+| `u128`   | `u128`   | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -735,22 +735,22 @@ let a: u8 = 128u8.mul_wrapped(2u8); // 0u8
 
 #### Description
 
-Multiplies `first` with `second`, wrapping around at the boundary of the type, and storing the outcome in `destination`.
+Multiplies `first` with `second`, wrapping around at the boundary of the type, and storing the result in `destination`.
 
 #### Supported Types
 
 | First  | Second | Destination |
 |--------|--------|-------------|
-| `I8`   | `I8`   | `I8`        |
-| `I16`  | `I16`  | `I16`       |
-| `I32`  | `I32`  | `I32`       |
-| `I64`  | `I64`  | `I64`       |
-| `I128` | `I128` | `I128`      |
-| `U8`   | `U8`   | `U8`        |
-| `U16`  | `U16`  | `U16`       |
-| `U32`  | `U32`  | `U32`       |
-| `U64`  | `U64`  | `U64`       |
-| `U128` | `U128` | `U128`      |
+| `i8`   | `i8`   | `i8`        |
+| `i16`  | `i16`  | `i16`       |
+| `i32`  | `i32`  | `i32`       |
+| `i64`  | `i64`  | `i64`       |
+| `i128` | `i128` | `i128`      |
+| `u8`   | `u8`   | `u8`        |
+| `u16`  | `u16`  | `u16`       |
+| `u32`  | `u32`  | `u32`       |
+| `u64`  | `u64`  | `u64`       |
+| `u128` | `u128` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -763,13 +763,14 @@ let a: bool = true.nand(false); // true
 
 #### Description
 
-Returns false only if `first` and `second` are true, storing the outcome in `destination`.
+Calculates the negated conjunction of `first` and `second`, storing the result in `destination`. 
+The result is false if and only if both first and second are true.
 
 #### Supported Types
 
 | First     | Second    | Destination |
 |-----------|-----------|-------------|
-| `Boolean` | `Boolean` | `Boolean`   |
+| `bool` | `bool` | `bool`   |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -782,7 +783,7 @@ let a: i8 = -1i8.neg(); // 1i8
 
 #### Description
 
-Negates `first`, storing the outcome in `destination`.
+Negates `first`, storing the result in `destination`.
 
 For signed integer types, calling `neg` on the minimum value is an invalid operation. For example, the input `-128i8` would not be valid since `128` cannot be represented as an `i8`.
 
@@ -790,13 +791,13 @@ For signed integer types, calling `neg` on the minimum value is an invalid opera
 
 | Input   | Destination |
 |---------|-------------|
-| `Field` | `Field`     |
-| `Group` | `Group`     |
-| `I8`    | `I8`        |
-| `I16`   | `I16`       |
-| `I32`   | `I32`       |
-| `I64`   | `I64`       |
-| `I128`  | `I128`      |
+| `field` | `field`     |
+| `group` | `group`     |
+| `i8`    | `i8`        |
+| `i16`   | `i16`       |
+| `i32`   | `i32`       |
+| `i64`   | `i64`       |
+| `i128`  | `i128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -809,13 +810,13 @@ let a: bool = false.nor(false); // true
 
 #### Description
 
-Returns true when neither `first` nor `second` is true, storing the outcome in `destination`.
+Returns true when neither `first` nor `second` is true, storing the result in `destination`.
 
 #### Supported Type
 
 | First     | Second    | Destination |
 |-----------|-----------|-------------|
-| `Boolean` | `Boolean` | `Boolean`   |
+| `bool` | `bool` | `bool`   |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -828,23 +829,23 @@ let a: bool = true.not(); // false
 
 #### Description
 
-Perform a NOT operation on an integer (bitwise) or boolean input, storing the outcome in `destination`.
+Perform a NOT operation on an integer (bitwise) or boolean input, storing the result in `destination`.
 
 #### Supported Types
 
 | Input     | Destination |
 |-----------|-------------|
-| `Boolean` | `Boolean`   |
-| `I8`      | `I8`        |
-| `I16`     | `I16`       |
-| `I32`     | `I32`       |
-| `I64`     | `I64`       |
-| `I128`    | `I128`      |
-| `U8`      | `U8`        |
-| `U16`     | `U16`       |
-| `U32`     | `U32`       |
-| `U64`     | `U64`       |
-| `U128`    | `U128`      |
+| `bool` | `bool`   |
+| `i8`      | `i8`        |
+| `i16`     | `i16`       |
+| `i32`     | `i32`       |
+| `i64`     | `i64`       |
+| `i128`    | `i128`      |
+| `u8`      | `u8`        |
+| `u16`     | `u16`       |
+| `u32`     | `u32`       |
+| `u64`     | `u64`       |
+| `u128`    | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -858,23 +859,23 @@ let b: bool = false.or(false); // false
 
 #### Description
 
-Performs an OR operation on integer (bitwise) or boolean `first` and `second`, storing the outcome in `destination`.
+Performs an OR operation on integer (bitwise) or boolean `first` and `second`, storing the result in `destination`.
 
 #### Supported Types
 
 | First     | Second    | Destination |
 |-----------|-----------|-------------|
-| `Boolean` | `Boolean` | `Boolean`   |
-| `I8`      | `I8`      | `I8`        |
-| `I16`     | `I16`     | `I16`       |
-| `I32`     | `I32`     | `I32`       |
-| `I64`     | `I64`     | `I64`       |
-| `I128`    | `I128`    | `I128`      |
-| `U8`      | `U8`      | `U8`        |
-| `U16`     | `U16`     | `U16`       |
-| `U32`     | `U32`     | `U32`       |
-| `U64`     | `U64`     | `U64`       |
-| `U128`    | `U128`    | `U128`      |
+| `bool` | `bool` | `bool`   |
+| `i8`      | `i8`      | `i8`        |
+| `i16`     | `i16`     | `i16`       |
+| `i32`     | `i32`     | `i32`       |
+| `i64`     | `i64`     | `i64`       |
+| `i128`    | `i128`    | `i128`      |
+| `u8`      | `u8`      | `u8`        |
+| `u16`     | `u16`     | `u16`       |
+| `u32`     | `u32`     | `u32`       |
+| `u64`     | `u64`     | `u64`       |
+| `u128`    | `u128`    | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -888,27 +889,27 @@ let b: u8 = a.pow(2u8); // 16u8
 
 #### Description
 
-Raises `first` to the power of `second`, storing the outcome in `destination`.
+Raises `first` to the power of `second`, storing the result in `destination`.
 
-For integer types, a constraint is added to check for overflow/underflow. For cases where wrapping semantics are needed for integer types, see the [pow_wrapped](#pow_wrapped) instruction.
+Note that execution will halt if the operation overflows/underflows. For cases where wrapping semantics are needed for integer types, see the [pow_wrapped](#pow_wrapped) instruction.
 
 #### Supported Types
 
-`Magnitude` can be a `U8`, `U16`, or `U32`.
+`Magnitude` can be a `u8`, `u16`, or `u32`.
 
 | First   | Second      | Destination |
 |---------|-------------|-------------|
-| `Field` | `Field`     | `Field`     |
-| `I8`    | `Magnitude` | `I8`        |
-| `I16`   | `Magnitude` | `I16`       |
-| `I32`   | `Magnitude` | `I32`       |
-| `I64`   | `Magnitude` | `I64`       |
-| `I128`  | `Magnitude` | `I128`      |
-| `U8`    | `Magnitude` | `U8`        |
-| `U16`   | `Magnitude` | `U16`       |
-| `U32`   | `Magnitude` | `U32`       |
-| `U64`   | `Magnitude` | `U64`       |
-| `U128`  | `Magnitude` | `U128`      |
+| `field` | `field`     | `field`     |
+| `i8`    | `Magnitude` | `i8`        |
+| `i16`   | `Magnitude` | `i16`       |
+| `i32`   | `Magnitude` | `i32`       |
+| `i64`   | `Magnitude` | `i64`       |
+| `i128`  | `Magnitude` | `i128`      |
+| `u8`    | `Magnitude` | `u8`        |
+| `u16`   | `Magnitude` | `u16`       |
+| `u32`   | `Magnitude` | `u32`       |
+| `u64`   | `Magnitude` | `u64`       |
+| `u128`  | `Magnitude` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -921,24 +922,24 @@ let a: u8 = 16u8.pow_wrapped(2u8); // 0u8
 
 #### Description
 
-Raises `first` to the power of `second`, wrapping around at the boundary of the type, storing the outcome in `destination`.
+Raises `first` to the power of `second`, wrapping around at the boundary of the type, storing the result in `destination`.
 
 #### Supported Types
 
-`Magnitude` can be a `U8`, `U16`, or `U32`.
+`Magnitude` can be a `u8`, `u16`, or `u32`.
 
 | First  | Second      | Destination |
 |--------|-------------|-------------|
-| `I8`   | `Magnitude` | `I8`        |
-| `I16`  | `Magnitude` | `I16`       |
-| `I32`  | `Magnitude` | `I32`       |
-| `I64`  | `Magnitude` | `I64`       |
-| `I128` | `Magnitude` | `I128`      |
-| `U8`   | `Magnitude` | `U8`        |
-| `U16`  | `Magnitude` | `U16`       |
-| `U32`  | `Magnitude` | `U32`       |
-| `U64`  | `Magnitude` | `U64`       |
-| `U128` | `Magnitude` | `U128`      |
+| `i8`   | `Magnitude` | `i8`        |
+| `i16`  | `Magnitude` | `i16`       |
+| `i32`  | `Magnitude` | `i32`       |
+| `i64`  | `Magnitude` | `i64`       |
+| `i128` | `Magnitude` | `i128`      |
+| `u8`   | `Magnitude` | `u8`        |
+| `u16`  | `Magnitude` | `u16`       |
+| `u32`  | `Magnitude` | `u32`       |
+| `u64`  | `Magnitude` | `u64`       |
+| `u128` | `Magnitude` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -953,10 +954,10 @@ let b: u8 = 4u8.rem(2u8); // 0u8
 
 #### Description
 
-Computes the truncated remainder of `first` divided by `second`, storing the outcome in `destination`. Halts on division by zero.
+Computes the truncated remainder of `first` divided by `second`, storing the result in `destination`. Halts on division by zero.
 
 
-A constraint is added to check for underflow.  This underflow happens when the associated division operation, [div](#div), underflows.
+Note that execution will halt if the operation underflows.  This underflow happens when the associated division operation, [div](#div), underflows.
 
 For cases where wrapping semantics are needed for integer types, see the [rem_wrapped](#rem_wrapped) instruction.
 
@@ -964,16 +965,16 @@ For cases where wrapping semantics are needed for integer types, see the [rem_wr
 
 | First  | Second | Destination |
 |--------|--------|-------------|
-| `I8`   | `I8`   | `I8`        |
-| `I16`  | `I16`  | `I16`       |
-| `I32`  | `I32`  | `I32`       |
-| `I64`  | `I64`  | `I64`       |
-| `I128` | `I128` | `I128`      |
-| `U8`   | `U8`   | `U8`        |
-| `U16`  | `U16`  | `U16`       |
-| `U32`  | `U32`  | `U32`       |
-| `U64`  | `U64`  | `U64`       |
-| `U128` | `U128` | `U128`      |
+| `i8`   | `i8`   | `i8`        |
+| `i16`  | `i16`  | `i16`       |
+| `i32`  | `i32`  | `i32`       |
+| `i64`  | `i64`  | `i64`       |
+| `i128` | `i128` | `i128`      |
+| `u8`   | `u8`   | `u8`        |
+| `u16`  | `u16`  | `u16`       |
+| `u32`  | `u32`  | `u32`       |
+| `u64`  | `u64`  | `u64`       |
+| `u128` | `u128` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -986,22 +987,22 @@ let b: i8 = a.rem_wrapped(-1i8); // 0i8
 ```
 
 #### Description
-Computes the truncated remainder of `first` divided by `second`, wrapping around at the boundary of the type, and storing the outcome in destination.
+Computes the truncated remainder of `first` divided by `second`, wrapping around at the boundary of the type, and storing the result in destination.
 
 #### Supported Types
 
 | First  | Second | Destination |
 |--------|--------|-------------|
-| `I8`   | `I8`   | `I8`        |
-| `I16`  | `I16`  | `I16`       |
-| `I32`  | `I32`  | `I32`       |
-| `I64`  | `I64`  | `I64`       |
-| `I128` | `I128` | `I128`      |
-| `U8`   | `U8`   | `U8`        |
-| `U16`  | `U16`  | `U16`       |
-| `U32`  | `U32`  | `U32`       |
-| `U64`  | `U64`  | `U64`       |
-| `U128` | `U128` | `U128`      |
+| `i8`   | `i8`   | `i8`        |
+| `i16`  | `i16`  | `i16`       |
+| `i32`  | `i32`  | `i32`       |
+| `i64`  | `i64`  | `i64`       |
+| `i128` | `i128` | `i128`      |
+| `u8`   | `u8`   | `u8`        |
+| `u16`  | `u16`  | `u16`       |
+| `u32`  | `u32`  | `u32`       |
+| `u64`  | `u64`  | `u64`       |
+| `u128` | `u128` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1018,13 +1019,15 @@ transition verify_field(s: signature, a: address, v: field) {
 
 #### Description
 
-Verifies that the signature `first` was signed by the address `second` with respect to the field `third`, storing the outcome in `destination`.
+Verifies that the signature `first` was signed by the address `second` with respect to the field `third`, storing the result in `destination`.
 
 #### Supported Types
 
+A `Message` is any literal or `struct` type.
+
 | First       | Second    | Third     | Destination |
 |-------------|-----------|-----------|-------------|
-| `Signature` | `Address` | `Message` | `Boolean`   |
+| `signature` | `address` | `Message` | `bool`   |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1038,24 +1041,24 @@ let b: u8 = a.shl(1u8); // 4u8
 
 #### Description
 
-Shifts `first` left by `second` bits, storing the outcome in `destination`.
+Shifts `first` left by `second` bits, storing the result in `destination`.
 
 #### Supported Types
 
-`Magnitude` can be a `U8`, `U16`, or `U32`.
+`Magnitude` can be a `u8`, `u16`, or `u32`.
 
 | First  | Second      | Destination |
 |--------|-------------|-------------|
-| `I8`   | `Magnitude` | `I8`        |
-| `I16`  | `Magnitude` | `I16`       |
-| `I32`  | `Magnitude` | `I32`       |
-| `I64`  | `Magnitude` | `I64`       |
-| `I128` | `Magnitude` | `I128`      |
-| `U8`   | `Magnitude` | `U8`        |
-| `U16`  | `Magnitude` | `U16`       |
-| `U32`  | `Magnitude` | `U32`       |
-| `U64`  | `Magnitude` | `U64`       |
-| `U128` | `Magnitude` | `U128`      |
+| `i8`   | `Magnitude` | `i8`        |
+| `i16`  | `Magnitude` | `i16`       |
+| `i32`  | `Magnitude` | `i32`       |
+| `i64`  | `Magnitude` | `i64`       |
+| `i128` | `Magnitude` | `i128`      |
+| `u8`   | `Magnitude` | `u8`        |
+| `u16`  | `Magnitude` | `u16`       |
+| `u32`  | `Magnitude` | `u32`       |
+| `u64`  | `Magnitude` | `u64`       |
+| `u128` | `Magnitude` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1068,24 +1071,24 @@ let a: u8 = 128u8.shl_wrapped(1u8); // 0u8
 
 #### Description
 
-Shifts `first` left by `second` bits, wrapping around at the boundary of the type, storing the outcome in `destination`.
+Shifts `first` left by `second` bits, wrapping around at the boundary of the type, storing the result in `destination`.
 
 #### Supported Types
 
-`Magnitude` can be a `U8`, `U16`, or `U32`.
+`Magnitude` can be a `u8`, `u16`, or `u32`.
 
 | First  | Second      | Destination |
 |--------|-------------|-------------|
-| `I8`   | `Magnitude` | `I8`        |
-| `I16`  | `Magnitude` | `I16`       |
-| `I32`  | `Magnitude` | `I32`       |
-| `I64`  | `Magnitude` | `I64`       |
-| `I128` | `Magnitude` | `I128`      |
-| `U8`   | `Magnitude` | `U8`        |
-| `U16`  | `Magnitude` | `U16`       |
-| `U32`  | `Magnitude` | `U32`       |
-| `U64`  | `Magnitude` | `U64`       |
-| `U128` | `Magnitude` | `U128`      |
+| `i8`   | `Magnitude` | `i8`        |
+| `i16`  | `Magnitude` | `i16`       |
+| `i32`  | `Magnitude` | `i32`       |
+| `i64`  | `Magnitude` | `i64`       |
+| `i128` | `Magnitude` | `i128`      |
+| `u8`   | `Magnitude` | `u8`        |
+| `u16`  | `Magnitude` | `u16`       |
+| `u32`  | `Magnitude` | `u32`       |
+| `u64`  | `Magnitude` | `u64`       |
+| `u128` | `Magnitude` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1099,24 +1102,24 @@ let b: u8 = a.shr(1u8); // 1u8
 
 #### Description
 
-Shifts `first` right by `second` bits, storing the outcome in `destination`.
+Shifts `first` right by `second` bits, storing the result in `destination`.
 
 #### Supported Types
 
-`Magnitude` can be a `U8`, `U16`, or `U32`.
+`Magnitude` can be a `u8`, `u16`, or `u32`.
 
 | First  | Second      | Destination |
 |--------|-------------|-------------|
-| `I8`   | `Magnitude` | `I8`        |
-| `I16`  | `Magnitude` | `I16`       |
-| `I32`  | `Magnitude` | `I32`       |
-| `I64`  | `Magnitude` | `I64`       |
-| `I128` | `Magnitude` | `I128`      |
-| `U8`   | `Magnitude` | `U8`        |
-| `U16`  | `Magnitude` | `U16`       |
-| `U32`  | `Magnitude` | `U32`       |
-| `U64`  | `Magnitude` | `U64`       |
-| `U128` | `Magnitude` | `U128`      |
+| `i8`   | `Magnitude` | `i8`        |
+| `i16`  | `Magnitude` | `i16`       |
+| `i32`  | `Magnitude` | `i32`       |
+| `i64`  | `Magnitude` | `i64`       |
+| `i128` | `Magnitude` | `i128`      |
+| `u8`   | `Magnitude` | `u8`        |
+| `u16`  | `Magnitude` | `u16`       |
+| `u32`  | `Magnitude` | `u32`       |
+| `u64`  | `Magnitude` | `u64`       |
+| `u128` | `Magnitude` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1129,24 +1132,24 @@ let a: u8 = 128u8.shr_wrapped(7u8); // 1u8
 
 #### Description
 
-Shifts `first` right by `second` bits, wrapping around at the boundary of the type, storing the outcome in `destination`.
+Shifts `first` right by `second` bits, wrapping around at the boundary of the type, storing the result in `destination`.
 
 #### Supported Types
 
-`Magnitude` can be a `U8`, `U16`, or `U32`.
+`Magnitude` can be a `u8`, `u16`, or `u32`.
 
 | First  | Second      | Destination |
 |--------|-------------|-------------|
-| `I8`   | `Magnitude` | `I8`        |
-| `I16`  | `Magnitude` | `I16`       |
-| `I32`  | `Magnitude` | `I32`       |
-| `I64`  | `Magnitude` | `I64`       |
-| `I128` | `Magnitude` | `I128`      |
-| `U8`   | `Magnitude` | `U8`        |
-| `U16`  | `Magnitude` | `U16`       |
-| `U32`  | `Magnitude` | `U32`       |
-| `U64`  | `Magnitude` | `U64`       |
-| `U128` | `Magnitude` | `U128`      |
+| `i8`   | `Magnitude` | `i8`        |
+| `i16`  | `Magnitude` | `i16`       |
+| `i32`  | `Magnitude` | `i32`       |
+| `i64`  | `Magnitude` | `i64`       |
+| `i128` | `Magnitude` | `i128`      |
+| `u8`   | `Magnitude` | `u8`        |
+| `u16`  | `Magnitude` | `u16`       |
+| `u32`  | `Magnitude` | `u32`       |
+| `u64`  | `Magnitude` | `u64`       |
+| `u128` | `Magnitude` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1159,13 +1162,13 @@ let a: field = 1field.square(); // 1field
 
 #### Description
 
-Squares the input, storing the outcome in `destination`.
+Squares the input, storing the result in `destination`.
 
 #### Supported Types
 
 | Input   | Destination |
 |---------|-------------|
-| `Field` | `Field`     |
+| `field` | `field`     |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1178,13 +1181,13 @@ let a: field = 1field.square_root(); // 1field
 
 #### Description
 
-Computes the square root of the input, storing the outcome in `destination`.
+Computes the square root of the input, storing the result in `destination`.
 
 #### Supported Types
 
 | Input   | Destination |
 |---------|-------------|
-| `Field` | `Field`     |
+| `field` | `field`     |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1199,24 +1202,24 @@ let b: u8 = a.sub(1u8); // 0u8
 
 #### Description
 
-Computes `first - second`, storing the outcome in `destination`.
+Computes `first - second`, storing the result in `destination`.
 
 #### Supported Types
 
 | First   | Second  | Destination |
 |---------|---------|-------------|
-| `Field` | `Field` | `Field`     |
-| `Group` | `Group` | `Group`     |
-| `I8`    | `I8`    | `I8`        |
-| `I16`   | `I16`   | `I16`       |
-| `I32`   | `I32`   | `I32`       |
-| `I64`   | `I64`   | `I64`       |
-| `I128`  | `I128`  | `I128`      |
-| `U8`    | `U8`    | `U8`        |
-| `U16`   | `U16`   | `U16`       |
-| `U32`   | `U32`   | `U32`       |
-| `U64`   | `U64`   | `U64`       |
-| `U128`  | `U128`  | `U128`      |
+| `field` | `field` | `field`     |
+| `group` | `group` | `group`     |
+| `i8`    | `i8`    | `i8`        |
+| `i16`   | `i16`   | `i16`       |
+| `i32`   | `i32`   | `i32`       |
+| `i64`   | `i64`   | `i64`       |
+| `i128`  | `i128`  | `i128`      |
+| `u8`    | `u8`    | `u8`        |
+| `u16`   | `u16`   | `u16`       |
+| `u32`   | `u32`   | `u32`       |
+| `u64`   | `u64`   | `u64`       |
+| `u128`  | `u128`  | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1229,22 +1232,22 @@ let a: u8 = 0u8.sub_wrapped(1u8); // 255u8
 
 #### Description
 
-Computes `first - second`, wrapping around at the boundary of the type, and storing the outcome in `destination`.
+Computes `first - second`, wrapping around at the boundary of the type, and storing the result in `destination`.
 
 #### Supported Types
 
 | First  | Second | Destination |
 |--------|--------|-------------|
-| `I8`   | `I8`   | `I8`        |
-| `I16`  | `I16`  | `I16`       |
-| `I32`  | `I32`  | `I32`       |
-| `I64`  | `I64`  | `I64`       |
-| `I128` | `I128` | `I128`      |
-| `U8`   | `U8`   | `U8`        |
-| `U16`  | `U16`  | `U16`       |
-| `U32`  | `U32`  | `U32`       |
-| `U64`  | `U64`  | `U64`       |
-| `U128` | `U128` | `U128`      |
+| `i8`   | `i8`   | `i8`        |
+| `i16`  | `i16`  | `i16`       |
+| `i32`  | `i32`  | `i32`       |
+| `i64`  | `i64`  | `i64`       |
+| `i128` | `i128` | `i128`      |
+| `u8`   | `u8`   | `u8`        |
+| `u16`  | `u16`  | `u16`       |
+| `u32`  | `u32`  | `u32`       |
+| `u64`  | `u64`  | `u64`       |
+| `u128` | `u128` | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1263,21 +1266,21 @@ Selects `first`, if `condition` is true, otherwise selects `second`, storing the
 
 | Condition | First       | Second      | Destination |
 |-----------|-------------|-------------|-------------|
-| `Boolean` | `Boolean`   | `Boolean`   | `Boolean`   |
-| `Boolean` | `Field`     | `Field`     | `Field`     |
-| `Boolean` | `Group`     | `Group`     | `Group`     |
-| `Boolean` | `I8`        | `I8`        | `I8`        |
-| `Boolean` | `I16`       | `I16`       | `I16`       |
-| `Boolean` | `I32`       | `I32`       | `I32`       |
-| `Boolean` | `I64`       | `I64`       | `I64`       |
-| `Boolean` | `I128`      | `I128`      | `I128`      |
-| `Boolean` | `U8`        | `U8`        | `U8`        |
-| `Boolean` | `U16`       | `U16`       | `U16`       |
-| `Boolean` | `U32`       | `U32`       | `U32`       |
-| `Boolean` | `U64`       | `U64`       | `U64`       |
-| `Boolean` | `U128`      | `U128`      | `U128`      |
-| `Boolean` | `Scalar`    | `Scalar`    | `Scalar`    |
-| `Boolean` | `Signature` | `Signature` | `Signature` |
+| `bool` | `bool`   | `bool`   | `bool`   |
+| `bool` | `field`     | `field`     | `field`     |
+| `bool` | `group`     | `group`     | `group`     |
+| `bool` | `i8`        | `i8`        | `i8`        |
+| `bool` | `i16`       | `i16`       | `i16`       |
+| `bool` | `i32`       | `i32`       | `i32`       |
+| `bool` | `i64`       | `i64`       | `i64`       |
+| `bool` | `i128`      | `i128`      | `i128`      |
+| `bool` | `u8`        | `u8`        | `u8`        |
+| `bool` | `u16`       | `u16`       | `u16`       |
+| `bool` | `u32`       | `u32`       | `u32`       |
+| `bool` | `u64`       | `u64`       | `u64`       |
+| `bool` | `u128`      | `u128`      | `u128`      |
+| `bool` | `scalar`    | `scalar`    | `scalar`    |
+| `bool` | `Signature` | `Signature` | `Signature` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1290,23 +1293,23 @@ let a: bool = true.xor(false); // true
 
 #### Description
 
-Performs a XOR operation on integer (bitwise) or boolean `first` and `second`, storing the outcome in `destination`.
+Performs a XOR operation on integer (bitwise) or boolean `first` and `second`, storing the result in `destination`.
 
 #### Supported Types
 
 | First     | Second    | Destination |
 |-----------|-----------|-------------|
-| `Boolean` | `Boolean` | `Boolean`   |
-| `I8`      | `I8`      | `I8`        |
-| `I16`     | `I16`     | `I16`       |
-| `I32`     | `I32`     | `I32`       |
-| `I64`     | `I64`     | `I64`       |
-| `I128`    | `I128`    | `I128`      |
-| `U8`      | `U8`      | `U8`        |
-| `U16`     | `U16`     | `U16`       |
-| `U32`     | `U32`     | `U32`       |
-| `U64`     | `U64`     | `U64`       |
-| `U128`    | `U128`    | `U128`      |
+| `bool` | `bool` | `bool`   |
+| `i8`      | `i8`      | `i8`        |
+| `i16`     | `i16`     | `i16`       |
+| `i32`     | `i32`     | `i32`       |
+| `i64`     | `i64`     | `i64`       |
+| `i128`    | `i128`    | `i128`      |
+| `u8`      | `u8`      | `u8`        |
+| `u16`     | `u16`     | `u16`       |
+| `u32`     | `u32`     | `u32`       |
+| `u64`     | `u64`     | `u64`       |
+| `u128`    | `u128`    | `u128`      |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1332,7 +1335,7 @@ It is an associated constant, whose name is `GEN` and whose associated type is `
 
 | Destination |
 |-------------|
-| `Group`     |
+| `group`     |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1366,21 +1369,21 @@ Returns a random value with the destination type.
 
 | Destination |
 |-------------|
-| `Address`   |
-| `Boolean`   |
-| `Field`     |
-| `Group`     |
-| `I8`        |
-| `I16`       |
-| `I32`       |
-| `I64`       |
-| `I128`      |
-| `U8`        |
-| `U16`       |
-| `U32`       |
-| `U64`       |
-| `U128`      |
-| `Scalar`    |
+| `address`   |
+| `bool`   |
+| `field`     |
+| `group`     |
+| `i8`        |
+| `i16`       |
+| `i32`       |
+| `i64`       |
+| `i128`      |
+| `u8`        |
+| `u16`       |
+| `u32`       |
+| `u64`       |
+| `u128`      |
+| `scalar`    |
 
 
 ### `BHP256::commit_to_DESTINATION`
@@ -1394,7 +1397,7 @@ let c: group = BHP256::commit_to_group(1field, salt);
 
 #### Description
 
-Computes a Bowe-Hopwood-Pedersen commitment on inputs of 256-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment can be an `Address`, `Field` or, `Group` value.
+Computes a Bowe-Hopwood-Pedersen commitment on inputs of 256-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment can be an `address`, `field` or, `group` value.
 
 The instruction will halt if the given input is smaller than 129 bits.
 
@@ -1402,22 +1405,22 @@ The instruction will halt if the given input is smaller than 129 bits.
 
 | First     | Second   | Destination                 |
 |-----------|----------|:----------------------------|
-| `Address` | `Scalar` | `Address`, `Field`, `Group` |
-| `Boolean` | `Scalar` | `Address`, `Field`, `Group` |
-| `Field`   | `Scalar` | `Address`, `Field`, `Group` |
-| `Group`   | `Scalar` | `Address`, `Field`, `Group` |
-| `I8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `I16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I64`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I128`    | `Scalar` | `Address`, `Field`, `Group` |
-| `U8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `U16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U64`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U128`    | `Scalar` | `Address`, `Field`, `Group` |
-| `Scalar`  | `Scalar` | `Address`, `Field`, `Group` |
-| `Struct`  | `Scalar` | `Address`, `Field`, `Group` |
+| `address` | `scalar` | `address`, `field`, `group` |
+| `bool` | `scalar` | `address`, `field`, `group` |
+| `field`   | `scalar` | `address`, `field`, `group` |
+| `group`   | `scalar` | `address`, `field`, `group` |
+| `i8`      | `scalar` | `address`, `field`, `group` |
+| `i16`     | `scalar` | `address`, `field`, `group` |
+| `i32`     | `scalar` | `address`, `field`, `group` |
+| `i64`     | `scalar` | `address`, `field`, `group` |
+| `i128`    | `scalar` | `address`, `field`, `group` |
+| `u8`      | `scalar` | `address`, `field`, `group` |
+| `u16`     | `scalar` | `address`, `field`, `group` |
+| `u32`     | `scalar` | `address`, `field`, `group` |
+| `u64`     | `scalar` | `address`, `field`, `group` |
+| `u128`    | `scalar` | `address`, `field`, `group` |
+| `scalar`  | `scalar` | `address`, `field`, `group` |
+| `struct`  | `scalar` | `address`, `field`, `group` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1433,7 +1436,7 @@ let c: group = BHP512::commit_to_group(1field, salt);
 
 #### Description
 
-Computes a Bowe-Hopwood-Pedersen commitment on inputs of 512-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment will always be a `Group` value.
+Computes a Bowe-Hopwood-Pedersen commitment on inputs of 512-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment will always be a `group` value.
 
 The instruction will halt if the given input is smaller than 171 bits.
 
@@ -1441,22 +1444,22 @@ The instruction will halt if the given input is smaller than 171 bits.
 
 | First     | Second   | Destination                 |
 |-----------|----------|:----------------------------|
-| `Address` | `Scalar` | `Address`, `Field`, `Group` |
-| `Boolean` | `Scalar` | `Address`, `Field`, `Group` |
-| `Field`   | `Scalar` | `Address`, `Field`, `Group` |
-| `Group`   | `Scalar` | `Address`, `Field`, `Group` |
-| `I8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `I16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I64`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I128`    | `Scalar` | `Address`, `Field`, `Group` |
-| `U8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `U16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U64`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U128`    | `Scalar` | `Address`, `Field`, `Group` |
-| `Scalar`  | `Scalar` | `Address`, `Field`, `Group` |
-| `Struct`  | `Scalar` | `Address`, `Field`, `Group` |
+| `address` | `scalar` | `address`, `field`, `group` |
+| `bool` | `scalar` | `address`, `field`, `group` |
+| `field`   | `scalar` | `address`, `field`, `group` |
+| `group`   | `scalar` | `address`, `field`, `group` |
+| `i8`      | `scalar` | `address`, `field`, `group` |
+| `i16`     | `scalar` | `address`, `field`, `group` |
+| `i32`     | `scalar` | `address`, `field`, `group` |
+| `i64`     | `scalar` | `address`, `field`, `group` |
+| `i128`    | `scalar` | `address`, `field`, `group` |
+| `u8`      | `scalar` | `address`, `field`, `group` |
+| `u16`     | `scalar` | `address`, `field`, `group` |
+| `u32`     | `scalar` | `address`, `field`, `group` |
+| `u64`     | `scalar` | `address`, `field`, `group` |
+| `u128`    | `scalar` | `address`, `field`, `group` |
+| `scalar`  | `scalar` | `address`, `field`, `group` |
+| `struct`  | `scalar` | `address`, `field`, `group` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1472,7 +1475,7 @@ let c: group = BHP768::commit_to_group(1field, salt);
 
 #### Description
 
-Computes a Bowe-Hopwood-Pedersen commitment on inputs of 768-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment will always be a `Group` value.
+Computes a Bowe-Hopwood-Pedersen commitment on inputs of 768-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment will always be a `group` value.
 
 The instruction will halt if the given input is smaller than 129 bits.
 
@@ -1480,22 +1483,22 @@ The instruction will halt if the given input is smaller than 129 bits.
 
 | First     | Second   | Destination                 |
 |-----------|----------|:----------------------------|
-| `Address` | `Scalar` | `Address`, `Field`, `Group` |
-| `Boolean` | `Scalar` | `Address`, `Field`, `Group` |
-| `Field`   | `Scalar` | `Address`, `Field`, `Group` |
-| `Group`   | `Scalar` | `Address`, `Field`, `Group` |
-| `I8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `I16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I64`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I128`    | `Scalar` | `Address`, `Field`, `Group` |
-| `U8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `U16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U64`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U128`    | `Scalar` | `Address`, `Field`, `Group` |
-| `Scalar`  | `Scalar` | `Address`, `Field`, `Group` |
-| `Struct`  | `Scalar` | `Address`, `Field`, `Group` |
+| `address` | `scalar` | `address`, `field`, `group` |
+| `bool` | `scalar` | `address`, `field`, `group` |
+| `field`   | `scalar` | `address`, `field`, `group` |
+| `group`   | `scalar` | `address`, `field`, `group` |
+| `i8`      | `scalar` | `address`, `field`, `group` |
+| `i16`     | `scalar` | `address`, `field`, `group` |
+| `i32`     | `scalar` | `address`, `field`, `group` |
+| `i64`     | `scalar` | `address`, `field`, `group` |
+| `i128`    | `scalar` | `address`, `field`, `group` |
+| `u8`      | `scalar` | `address`, `field`, `group` |
+| `u16`     | `scalar` | `address`, `field`, `group` |
+| `u32`     | `scalar` | `address`, `field`, `group` |
+| `u64`     | `scalar` | `address`, `field`, `group` |
+| `u128`    | `scalar` | `address`, `field`, `group` |
+| `scalar`  | `scalar` | `address`, `field`, `group` |
+| `struct`  | `scalar` | `address`, `field`, `group` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1511,7 +1514,7 @@ let c: group = BHP1024::commit_to_group(1field, salt);
 
 #### Description
 
-Computes a Bowe-Hopwood-Pedersen commitment on inputs of 1024-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment will always be a `Group` value.
+Computes a Bowe-Hopwood-Pedersen commitment on inputs of 1024-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment will always be a `group` value.
 
 The instruction will halt if the given input is smaller than 171 bits.
 
@@ -1519,22 +1522,22 @@ The instruction will halt if the given input is smaller than 171 bits.
 
 | First     | Second   | Destination                 |
 |-----------|----------|:----------------------------|
-| `Address` | `Scalar` | `Address`, `Field`, `Group` |
-| `Boolean` | `Scalar` | `Address`, `Field`, `Group` |
-| `Field`   | `Scalar` | `Address`, `Field`, `Group` |
-| `Group`   | `Scalar` | `Address`, `Field`, `Group` |
-| `I8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `I16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I64`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I128`    | `Scalar` | `Address`, `Field`, `Group` |
-| `U8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `U16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U64`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U128`    | `Scalar` | `Address`, `Field`, `Group` |
-| `Scalar`  | `Scalar` | `Address`, `Field`, `Group` |
-| `Struct`  | `Scalar` | `Address`, `Field`, `Group` |
+| `address` | `scalar` | `address`, `field`, `group` |
+| `bool` | `scalar` | `address`, `field`, `group` |
+| `field`   | `scalar` | `address`, `field`, `group` |
+| `group`   | `scalar` | `address`, `field`, `group` |
+| `i8`      | `scalar` | `address`, `field`, `group` |
+| `i16`     | `scalar` | `address`, `field`, `group` |
+| `i32`     | `scalar` | `address`, `field`, `group` |
+| `i64`     | `scalar` | `address`, `field`, `group` |
+| `i128`    | `scalar` | `address`, `field`, `group` |
+| `u8`      | `scalar` | `address`, `field`, `group` |
+| `u16`     | `scalar` | `address`, `field`, `group` |
+| `u32`     | `scalar` | `address`, `field`, `group` |
+| `u64`     | `scalar` | `address`, `field`, `group` |
+| `u128`    | `scalar` | `address`, `field`, `group` |
+| `scalar`  | `scalar` | `address`, `field`, `group` |
+| `struct`  | `scalar` | `address`, `field`, `group` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1550,22 +1553,22 @@ let c: group = Pedersen64::commit_to_group(1field, salt);
 
 #### Description
 
-Computes a Pedersen commitment up to a 64-bit input in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment will always be a `Group` value.
+Computes a Pedersen commitment up to a 64-bit input in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment will always be a `group` value.
 
-The instruction will halt if the given `Struct` value exceeds the 64-bit limit.
+The instruction will halt if the given `struct` value exceeds the 64-bit limit.
 
 #### Supported Types
 
 | First     | Second   | Destination                 |
 |-----------|----------|:----------------------------|
-| `Boolean` | `Scalar` | `Address`, `Field`, `Group` |
-| `I8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `I16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `U16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `Struct`  | `Scalar` | `Address`, `Field`, `Group` |
+| `bool` | `scalar` | `address`, `field`, `group` |
+| `i8`      | `scalar` | `address`, `field`, `group` |
+| `i16`     | `scalar` | `address`, `field`, `group` |
+| `i32`     | `scalar` | `address`, `field`, `group` |
+| `u8`      | `scalar` | `address`, `field`, `group` |
+| `u16`     | `scalar` | `address`, `field`, `group` |
+| `u32`     | `scalar` | `address`, `field`, `group` |
+| `struct`  | `scalar` | `address`, `field`, `group` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1581,25 +1584,25 @@ let c: group = Pedersen64::commit_to_group(1field, salt);
 
 #### Description
 
-Computes a Pedersen commitment up to a 128-bit input in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment will always be a `Group` value.
+Computes a Pedersen commitment up to a 128-bit input in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment will always be a `group` value.
 
-The instruction will halt if the given `Struct` value exceeds the 128-bit limit.
+The instruction will halt if the given `struct` value exceeds the 128-bit limit.
 
 
 #### Supported Types
 
 | First     | Second   | Destination                 |
 |-----------|----------|:----------------------------|
-| `Boolean` | `Scalar` | `Address`, `Field`, `Group` |
-| `I8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `I16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `I64`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U8`      | `Scalar` | `Address`, `Field`, `Group` |
-| `U16`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U32`     | `Scalar` | `Address`, `Field`, `Group` |
-| `U64`     | `Scalar` | `Address`, `Field`, `Group` |
-| `Struct`  | `Scalar` | `Address`, `Field`, `Group` |
+| `bool` | `scalar` | `address`, `field`, `group` |
+| `i8`      | `scalar` | `address`, `field`, `group` |
+| `i16`     | `scalar` | `address`, `field`, `group` |
+| `i32`     | `scalar` | `address`, `field`, `group` |
+| `i64`     | `scalar` | `address`, `field`, `group` |
+| `u8`      | `scalar` | `address`, `field`, `group` |
+| `u16`     | `scalar` | `address`, `field`, `group` |
+| `u32`     | `scalar` | `address`, `field`, `group` |
+| `u64`     | `scalar` | `address`, `field`, `group` |
+| `struct`  | `scalar` | `address`, `field`, `group` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1626,7 +1629,7 @@ let result: u128 = BHP256::hash_to_u128(1field);
 
 #### Description
 
-Computes a Bowe-Hopwood-Pedersen hash on inputs of 256-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Computes a Bowe-Hopwood-Pedersen hash on inputs of 256-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 The instruction will halt if the given input is smaller than 129 bits.
 
@@ -1634,22 +1637,22 @@ The instruction will halt if the given input is smaller than 129 bits.
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1675,7 +1678,7 @@ let result: u128 = BHP512::hash_to_u128(1field);
 
 #### Description
 
-Computes a Bowe-Hopwood-Pedersen hash on inputs of 512-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Computes a Bowe-Hopwood-Pedersen hash on inputs of 512-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 The instruction will halt if the given input is smaller than 171 bits.
 
@@ -1683,22 +1686,22 @@ The instruction will halt if the given input is smaller than 171 bits.
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1724,7 +1727,7 @@ let result: u128 = BHP768::hash_to_u128(1field);
 
 #### Description
 
-Computes a Bowe-Hopwood-Pedersen hash on inputs of 768-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Computes a Bowe-Hopwood-Pedersen hash on inputs of 768-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 The instruction will halt if the given input is smaller than 129 bits.
 
@@ -1732,22 +1735,22 @@ The instruction will halt if the given input is smaller than 129 bits.
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1773,7 +1776,7 @@ let result: u128 = BHP1024::hash_to_u128(1field);
 
 #### Description
 
-Computes a Bowe-Hopwood-Pedersen hash on inputs of 1024-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Computes a Bowe-Hopwood-Pedersen hash on inputs of 1024-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 The instruction will halt if the given input is smaller than 171 bits.
 
@@ -1781,22 +1784,22 @@ The instruction will halt if the given input is smaller than 171 bits.
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1823,28 +1826,28 @@ let result: u128 = Keccak256::hash_to_u128(1field);
 #### Description
 
 Computes a Keccak256 hash on inputs of 256-bit chunks in `first`, storing the hash in `destination`.
-The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1871,28 +1874,28 @@ let result: u128 = Keccak384::hash_to_u128(1field);
 #### Description
 
 Computes a Keccak384 hash on inputs of 256-bit chunks in `first`, storing the hash in `destination`.
-The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1919,28 +1922,28 @@ let result: u128 = Keccak512::hash_to_u128(1field);
 #### Description
 
 Computes a Keccak512 hash on inputs of 256-bit chunks in `first`, storing the hash in `destination`.
-The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -1966,22 +1969,22 @@ let result: u128 = Pedersen64::hash_to_u128(1field);
 
 #### Description
 
-Computes a Pedersen hash up to a 64-bit input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Computes a Pedersen hash up to a 64-bit input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
-The instruction will halt if the given `Struct` value exceeds the 64-bit limit.
+The instruction will halt if the given `struct` value exceeds the 64-bit limit.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -2007,24 +2010,24 @@ let result: u128 = Pedersen128::hash_to_u128(1field);
 
 #### Description
 
-Computes a Pedersen hash up to a 128-bit input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Computes a Pedersen hash up to a 128-bit input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
-The instruction will halt if the given `Struct` value exceeds the 64-bit limit.
+The instruction will halt if the given `struct` value exceeds the 64-bit limit.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -2051,28 +2054,28 @@ let result: u128 = Poseidon2::hash_to_u128(1field);
 
 #### Description
 
-Calculates a Poseidon hash with an input rate of 2, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Calculates a Poseidon hash with an input rate of 2, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -2099,28 +2102,28 @@ let result: u128 = Poseidon4::hash_to_u128(1field);
 
 #### Description
 
-Calculates a Poseidon hash with an input rate of 4, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Calculates a Poseidon hash with an input rate of 4, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -2147,28 +2150,28 @@ let result: u128 = Poseidon8::hash_to_u128(1field);
 
 #### Description
 
-Calculates a Poseidon hash with an input rate of 8, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Calculates a Poseidon hash with an input rate of 8, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -2194,28 +2197,28 @@ let result: u128 = SHA3_256::hash_to_u128(1field);
 
 #### Description
 
-Calculates a SHA3_256 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Calculates a SHA3_256 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -2241,28 +2244,28 @@ let result: u128 = SHA3_384::hash_to_u128(1field);
 
 #### Description
 
-Calculates a SHA3_384 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Calculates a SHA3_384 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
@@ -2288,28 +2291,28 @@ let result: u128 = SHA3_512::hash_to_u128(1field);
 
 #### Description
 
-Calculates a SHA3_512 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function.
+Calculates a SHA3_512 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function.
 
 #### Supported Types
 
 | First     | Destination                                                                                               |
 |-----------|:----------------------------------------------------------------------------------------------------------|
-| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Field`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Group`   | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `I128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U8`      | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U16`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U32`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U64`     | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `U128`    | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Scalar`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
-| `Struct`  | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` |
+| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `field`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `group`   | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `i128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u8`      | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u16`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u32`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u64`     | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `u128`    | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `scalar`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
+| `struct`  | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` |
 
 [Back to Top](#table-of-standard-operators)
 ***
diff --git a/documentation/leo/08_resources.md b/documentation/leo/08_resources.md
index 3f70502ba..fab4e6bde 100644
--- a/documentation/leo/08_resources.md
+++ b/documentation/leo/08_resources.md
@@ -142,7 +142,9 @@ as well as the recommended code solution.
 
 ### Conditional Branches
 
-Conditional `if else` statements in Leo are expensive. It is preferred to use ternary `? :` expressions.
+The Leo compiler rewrites if-else statements inside `transitions` into a sequence of ternary expressions.
+This is because the underlying circuit construction does not support branching.
+For precise control over the circuit size, it is recommended to use ternary expressions directly.
 
 ```leo title="Example:"
 if (condition) {

From c881c28ed6bf8aea28704987ebb4a3df27010c91 Mon Sep 17 00:00:00 2001
From: Pranav Gaddamadugu <23022326+d0cd@users.noreply.github.com>
Date: Sun, 28 Jul 2024 09:57:17 -0700
Subject: [PATCH 2/5] Rename create-aleo-app to create-leo-app

---
 documentation/00_getting_started.md                 |   2 +-
 documentation/00_sdk_overview.md                    |  12 ++++++------
 .../00_app_installation.md                          |   4 ++--
 .../01_create_leo_app.md}                           |   4 ++--
 .../images/decrypt-record.png                       | Bin
 .../images/deployment-console.png                   | Bin
 .../images/deployment-success.png                   | Bin
 .../images/execution-console.png                    | Bin
 .../images/execution-success.png                    | Bin
 .../images/get-transaction.png                      | Bin
 documentation/sdk/typescript/00_sdk_overview.md     |   8 ++++----
 documentation/sdk/wasm/00_wasm_installation.md      |   4 ++--
 12 files changed, 17 insertions(+), 17 deletions(-)
 rename documentation/sdk/{create-aleo-app => create-leo-app}/00_app_installation.md (74%)
 rename documentation/sdk/{create-aleo-app/01_create_aleo_app.md => create-leo-app/01_create_leo_app.md} (97%)
 rename documentation/sdk/{create-aleo-app => create-leo-app}/images/decrypt-record.png (100%)
 rename documentation/sdk/{create-aleo-app => create-leo-app}/images/deployment-console.png (100%)
 rename documentation/sdk/{create-aleo-app => create-leo-app}/images/deployment-success.png (100%)
 rename documentation/sdk/{create-aleo-app => create-leo-app}/images/execution-console.png (100%)
 rename documentation/sdk/{create-aleo-app => create-leo-app}/images/execution-success.png (100%)
 rename documentation/sdk/{create-aleo-app => create-leo-app}/images/get-transaction.png (100%)

diff --git a/documentation/00_getting_started.md b/documentation/00_getting_started.md
index 18a672be5..321af6640 100644
--- a/documentation/00_getting_started.md
+++ b/documentation/00_getting_started.md
@@ -12,7 +12,7 @@ to compile, execute, and finalize its state autonomously.
 # What's new on Aleo?  
 ### [**🔧 Getting Ready for Testnet Beta**](./leo/17_testnet_beta.md) - A guide on updating your Leo applications for Testnet Beta.
 ### [**🤝 Leo Core Developers Call**](./leo/16_core_devs_call.md) - Collaborate with the Leo development team and ecosystem on the future of Leo.
-### [**⚛️ Create Aleo App**](./sdk/create-aleo-app/01_create_aleo_app.md) - A full stack application written in Typescript using Leo and React.
+### [**⚛️ Create Leo App**](./sdk/create-leo-app/01_create_leo_app.md) - A full stack application written in Typescript using Leo and React.
 ### [**🧰 Leo Developer Toolkit**](./testnet/getting_started/04_developer_toolkit.md) - A zero to one tutorial for the Leo programming language.
 :::
 
diff --git a/documentation/00_sdk_overview.md b/documentation/00_sdk_overview.md
index bb640fb9d..304acda29 100644
--- a/documentation/00_sdk_overview.md
+++ b/documentation/00_sdk_overview.md
@@ -33,9 +33,9 @@ first zero knowledge web app.
 #### Source: [`sdk/sdk`](https://github.com/AleoHQ/sdk/tree/testnet3/sdk)
 
 
-## 2. [Create-Aleo-App](./sdk/create-aleo-app/00_app_installation.md) - Zero Knowledge Web App Examples
+## 2. [Create-Aleo-App](./sdk/create-leo-app/00_app_installation.md) - Zero Knowledge Web App Examples
 
-<a href="https://www.npmjs.com/package/create-aleo-app"> <img alt="Create Aleo App" src="https://img.shields.io/npm/l/create-aleo-app?label=NPM%20-%20Create-Aleo-App&labelColor=green&color=blue" /></a>
+<a href="https://www.npmjs.com/package/create-leo-app"> <img alt="Create Leo App" src="https://img.shields.io/npm/l/create-leo-app?label=NPM%20-%20Create-Aleo-App&labelColor=green&color=blue" /></a>
 
 Create-aleo-app provides zero-knowledge web app examples in common web frameworks such as React. Developers looking to
 start with working examples should start here.
@@ -45,15 +45,15 @@ start with working examples should start here.
 
 You can start with a template by running
 ```bash
-npm create aleo-app@latest
+npm create leo-app@latest
 ```
 
-#### Source: [`sdk/create-aleo-app`](https://github.com/AleoHQ/sdk/tree/testnet3/create-aleo-app)
+#### Source: [`sdk/create-leo-app`](https://github.com/AleoHQ/sdk/tree/testnet3/create-leo-app)
 
 ## 3. [Aleo-Wasm](./sdk/wasm/00_wasm_installation.md) - Zero Knowledge Algorithms in JavaScript + WebAssembly
 
-<a href="https://www.npmjs.com/package/@aleohq/wasm"> <img alt="Create Aleo App" src="https://img.shields.io/npm/l/%40aleohq%2Fwasm?label=NPM%20-%20Aleo%20Wasm&labelColor=green&color=blue" /></a>
-<a href="https://www.npmjs.com/package/@aleohq/nodejs"> <img alt="Create Aleo App" src="https://img.shields.io/npm/l/%40aleohq%2Fnodejs?label=NPM%20-%20Aleo%20Nodejs&labelColor=green&color=blue" /></a>
+<a href="https://www.npmjs.com/package/@aleohq/wasm"> <img alt="Create Leo App" src="https://img.shields.io/npm/l/%40aleohq%2Fwasm?label=NPM%20-%20Aleo%20Wasm&labelColor=green&color=blue" /></a>
+<a href="https://www.npmjs.com/package/@aleohq/nodejs"> <img alt="Create Leo App" src="https://img.shields.io/npm/l/%40aleohq%2Fnodejs?label=NPM%20-%20Aleo%20Nodejs&labelColor=green&color=blue" /></a>
 <a href="https://crates.io/crates/aleo-wasm"> <img alt="Aleo-Wasm" src="https://img.shields.io/crates/v/aleo-wasm.svg?color=neon" /></a>
 
 Aleo Wasm is a Rust crate which compiles Aleo code responsible for creating and executing zero knowledge programs into
diff --git a/documentation/sdk/create-aleo-app/00_app_installation.md b/documentation/sdk/create-leo-app/00_app_installation.md
similarity index 74%
rename from documentation/sdk/create-aleo-app/00_app_installation.md
rename to documentation/sdk/create-leo-app/00_app_installation.md
index c64255c35..ba7852ff3 100644
--- a/documentation/sdk/create-aleo-app/00_app_installation.md
+++ b/documentation/sdk/create-leo-app/00_app_installation.md
@@ -1,10 +1,10 @@
 ---
 id: installation
-title: Create Aleo App
+title: Create Leo App
 sidebar_label: Installation
 ---
 
-<a href="https://www.npmjs.com/package/create-aleo-app"> <img alt="Create Aleo App" src="https://img.shields.io/npm/l/create-aleo-app?label=NPM%20-%20Create-Aleo-App&labelColor=green&color=blue" /></a>
+<a href="https://www.npmjs.com/package/create-leo-app"> <img alt="Create Leo App" src="https://img.shields.io/npm/l/create-leo-app?label=NPM%20-%20Create-Aleo-App&labelColor=green&color=blue" /></a>
 
 ## Scaffolding Your First Aleo Project
 
diff --git a/documentation/sdk/create-aleo-app/01_create_aleo_app.md b/documentation/sdk/create-leo-app/01_create_leo_app.md
similarity index 97%
rename from documentation/sdk/create-aleo-app/01_create_aleo_app.md
rename to documentation/sdk/create-leo-app/01_create_leo_app.md
index c4457962b..296182abb 100644
--- a/documentation/sdk/create-aleo-app/01_create_aleo_app.md
+++ b/documentation/sdk/create-leo-app/01_create_leo_app.md
@@ -1,10 +1,10 @@
 ---
 id: tutorial
-title: Create Aleo App - React + JS + Leo Tutorial
+title: Create Leo App - React + JS + Leo Tutorial
 sidebar_label: React + JS + Leo Tutorial
 ---
 
-<a href="https://www.npmjs.com/package/create-aleo-app"> <img alt="Create Aleo App" src="https://img.shields.io/npm/l/create-aleo-app?label=NPM%20-%20Create-Aleo-App&labelColor=green&color=blue" /></a>
+<a href="https://www.npmjs.com/package/create-leo-app"> <img alt="Create Leo App" src="https://img.shields.io/npm/l/create-leo-app?label=NPM%20-%20Create-Aleo-App&labelColor=green&color=blue" /></a>
 
 
 ## 1. Installation
diff --git a/documentation/sdk/create-aleo-app/images/decrypt-record.png b/documentation/sdk/create-leo-app/images/decrypt-record.png
similarity index 100%
rename from documentation/sdk/create-aleo-app/images/decrypt-record.png
rename to documentation/sdk/create-leo-app/images/decrypt-record.png
diff --git a/documentation/sdk/create-aleo-app/images/deployment-console.png b/documentation/sdk/create-leo-app/images/deployment-console.png
similarity index 100%
rename from documentation/sdk/create-aleo-app/images/deployment-console.png
rename to documentation/sdk/create-leo-app/images/deployment-console.png
diff --git a/documentation/sdk/create-aleo-app/images/deployment-success.png b/documentation/sdk/create-leo-app/images/deployment-success.png
similarity index 100%
rename from documentation/sdk/create-aleo-app/images/deployment-success.png
rename to documentation/sdk/create-leo-app/images/deployment-success.png
diff --git a/documentation/sdk/create-aleo-app/images/execution-console.png b/documentation/sdk/create-leo-app/images/execution-console.png
similarity index 100%
rename from documentation/sdk/create-aleo-app/images/execution-console.png
rename to documentation/sdk/create-leo-app/images/execution-console.png
diff --git a/documentation/sdk/create-aleo-app/images/execution-success.png b/documentation/sdk/create-leo-app/images/execution-success.png
similarity index 100%
rename from documentation/sdk/create-aleo-app/images/execution-success.png
rename to documentation/sdk/create-leo-app/images/execution-success.png
diff --git a/documentation/sdk/create-aleo-app/images/get-transaction.png b/documentation/sdk/create-leo-app/images/get-transaction.png
similarity index 100%
rename from documentation/sdk/create-aleo-app/images/get-transaction.png
rename to documentation/sdk/create-leo-app/images/get-transaction.png
diff --git a/documentation/sdk/typescript/00_sdk_overview.md b/documentation/sdk/typescript/00_sdk_overview.md
index 7bc008122..4be17c567 100644
--- a/documentation/sdk/typescript/00_sdk_overview.md
+++ b/documentation/sdk/typescript/00_sdk_overview.md
@@ -32,7 +32,7 @@ The Aleo SDK provides the following functionality (Click to see examples):
 * [Installation](#Installation)
 * [Usage](#Usage)
     * [Zero Knowledge Web App Examples](#Zero-Knowledge-Web-App-Examples)
-        * [Create Aleo App](#create-aleo-app)
+        * [Create Leo App](#create-leo-app)
         * [provable.tools](#provabletools)
     * [Create An Aleo Account](#1-create-an-aleo-account)
     * [Execute Aleo Programs](#2-execute-aleo-programs)
@@ -75,9 +75,9 @@ To build the project from source, go to this project's root and execute:
 
 ## Zero Knowledge Web App Examples
 
-### Create Aleo App
+### Create Leo App
 A set of fully functional examples of zero knowledge web apps can be found in
-[create-aleo-app](https://github.com/AleoHQ/sdk/tree/testnet3/create-aleo-app). Create-aleo-app provides several web-app
+[create-leo-app](https://github.com/AleoHQ/sdk/tree/testnet3/create-leo-app). Create-aleo-app provides several web-app
 templates in common web frameworks such as React that can be used as a starting point for building zero knowledge web apps.
 
 Developers can get started immediately with create-react-app by running:
@@ -663,7 +663,7 @@ Make sure that you included custom types in your `tsconfig` file.
 </details>
 
 
-A full example of this implementation can be found [here](https://github.com/AleoHQ/sdk/blob/testnet3/create-aleo-app/template-react-leo/src/App.jsx)
+A full example of this implementation can be found [here](https://github.com/AleoHQ/sdk/blob/testnet3/create-leo-app/template-react-leo/src/App.jsx)
 
 ## 3. Aleo Credit Transfers
 
diff --git a/documentation/sdk/wasm/00_wasm_installation.md b/documentation/sdk/wasm/00_wasm_installation.md
index 5c30253b0..d0f081f48 100644
--- a/documentation/sdk/wasm/00_wasm_installation.md
+++ b/documentation/sdk/wasm/00_wasm_installation.md
@@ -5,8 +5,8 @@ sidebar_label: Installation
 ---
 
 <!-- markdown-link-check-disable -->
-<a href="https://www.npmjs.com/package/@aleohq/wasm"> <img alt="Create Aleo App" src="https://img.shields.io/npm/l/%40aleohq%2Fwasm?label=NPM%20-%20Aleo%20Wasm&labelColor=green&color=blue" /></a>
-<a href="https://www.npmjs.com/package/@aleohq/nodejs"> <img alt="Create Aleo App" src="https://img.shields.io/npm/l/%40aleohq%2Fnodejs?label=NPM%20-%20Aleo%20Nodejs&labelColor=green&color=blue" /></a>
+<a href="https://www.npmjs.com/package/@aleohq/wasm"> <img alt="Create Leo App" src="https://img.shields.io/npm/l/%40aleohq%2Fwasm?label=NPM%20-%20Aleo%20Wasm&labelColor=green&color=blue" /></a>
+<a href="https://www.npmjs.com/package/@aleohq/nodejs"> <img alt="Create Leo App" src="https://img.shields.io/npm/l/%40aleohq%2Fnodejs?label=NPM%20-%20Aleo%20Nodejs&labelColor=green&color=blue" /></a>
 <a href="https://crates.io/crates/aleo-wasm"> <img alt="Aleo-Wasm" src="https://img.shields.io/crates/v/aleo-wasm.svg?color=neon" /></a>
 
 [![github]](https://github.com/AleoHQ/sdk)&ensp;[![crates-io]](https://crates.io/crates/aleo-wasm)&ensp;[![docs-rs]](https://docs.rs/aleo-wasm/latest/aleo-wasm/)

From d83218bd0ff002873838887079526ec0b02c9025 Mon Sep 17 00:00:00 2001
From: d0cd <23022326+d0cd@users.noreply.github.com>
Date: Mon, 29 Jul 2024 09:15:05 -0700
Subject: [PATCH 3/5] Update documentation/leo/03_language.md

Co-authored-by: Eric McCarthy <7607035+bendyarm@users.noreply.github.com>
Signed-off-by: d0cd <23022326+d0cd@users.noreply.github.com>
---
 documentation/leo/03_language.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/leo/03_language.md b/documentation/leo/03_language.md
index c9ed35f02..0bd639b00 100644
--- a/documentation/leo/03_language.md
+++ b/documentation/leo/03_language.md
@@ -601,7 +601,7 @@ Return statements are declared as `return {expression};`.
 
 ### For Loops
 
-For loops are declared as `for {variable: type} in {lower bound}..{upper bound}`. The loop bounds must be integer types and constant. Furthermore, the lower bound must be
+For loops are declared as `for {variable: type} in {lower bound}..{upper bound}`. The loop bounds must be integer constants of the same type. Furthermore, the lower bound must be
 less than the upper bound. Nested loops are supported.
 
 

From 10b8ea4aa20e17747e4818e6175a838d823eab68 Mon Sep 17 00:00:00 2001
From: Pranav Gaddamadugu <23022326+d0cd@users.noreply.github.com>
Date: Thu, 1 Aug 2024 08:02:30 -0700
Subject: [PATCH 4/5] Broken links

---
 documentation/00_getting_started.md | 2 +-
 documentation/00_sdk_overview.md    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/documentation/00_getting_started.md b/documentation/00_getting_started.md
index f1ad6e00f..2122ee76e 100644
--- a/documentation/00_getting_started.md
+++ b/documentation/00_getting_started.md
@@ -12,7 +12,7 @@ to compile, execute, and finalize its state autonomously.
 # What's new on Aleo?  
 ### [**🔧 Getting Ready for Testnet Beta**](./leo/16_testnet_beta.md) - A guide on updating your Leo applications for Testnet Beta.
 ### [**🤝 Leo Core Developers Call**](./leo/15_core_devs_call.md) - Collaborate with the Leo development team and ecosystem on the future of Leo.
-### [**⚛️ Create Aleo App**](./sdk/create-aleo-app/01_create_aleo_app.md) - A full stack application written in Typescript using Leo and React.
+### [**⚛️ Create Aleo App**](./sdk/create-leo-app/01_create_aleo_app.md) - A full stack application written in Typescript using Leo and React.
 ### [**🧰 Leo Developer Toolkit**](./testnet/getting_started/04_developer_toolkit.md) - A zero to one tutorial for the Leo programming language.
 :::
 
diff --git a/documentation/00_sdk_overview.md b/documentation/00_sdk_overview.md
index 26effe1e7..88b466fd0 100644
--- a/documentation/00_sdk_overview.md
+++ b/documentation/00_sdk_overview.md
@@ -32,7 +32,7 @@ first zero knowledge web app.
 #### Source: [`sdk/sdk`](https://github.com/AleoHQ/sdk/tree/testnet3/sdk)
 
 
-## 2. [Create-leo-App](./sdk/create-aleo-app/00_app_installation.md) - Zero-Knowledge Web App Examples
+## 2. [Create-leo-App](./sdk/create-leo-app/00_app_installation.md) - Zero-Knowledge Web App Examples
 
 <a href="https://www.npmjs.com/package/create-leo-app"> <img alt="Create Leo App" src="https://img.shields.io/npm/l/create-aleo-app?label=NPM%20-%20Create-Leo-App&labelColor=green&color=blue" /></a>
 

From e42aba179c7d3d8db2a03944d2b8c064a1f0eaf5 Mon Sep 17 00:00:00 2001
From: Pranav Gaddamadugu <23022326+d0cd@users.noreply.github.com>
Date: Thu, 1 Aug 2024 08:04:31 -0700
Subject: [PATCH 5/5] Broken links

---
 documentation/00_getting_started.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/00_getting_started.md b/documentation/00_getting_started.md
index 2122ee76e..86f541422 100644
--- a/documentation/00_getting_started.md
+++ b/documentation/00_getting_started.md
@@ -12,7 +12,7 @@ to compile, execute, and finalize its state autonomously.
 # What's new on Aleo?  
 ### [**🔧 Getting Ready for Testnet Beta**](./leo/16_testnet_beta.md) - A guide on updating your Leo applications for Testnet Beta.
 ### [**🤝 Leo Core Developers Call**](./leo/15_core_devs_call.md) - Collaborate with the Leo development team and ecosystem on the future of Leo.
-### [**⚛️ Create Aleo App**](./sdk/create-leo-app/01_create_aleo_app.md) - A full stack application written in Typescript using Leo and React.
+### [**⚛️ Create Aleo App**](./sdk/create-leo-app/01_create_leo_app.md) - A full stack application written in Typescript using Leo and React.
 ### [**🧰 Leo Developer Toolkit**](./testnet/getting_started/04_developer_toolkit.md) - A zero to one tutorial for the Leo programming language.
 :::