From e46abebbd5e64c9f64127262b49408f14346a7f6 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 9 Sep 2024 13:53:13 +0300
Subject: [PATCH 01/30] chore: Empty precompile

---
 core/src/runtime/record.rs                  |  19 ++
 core/src/runtime/syscall.rs                 |  10 ++
 core/src/stark/air.rs                       |   6 +
 core/src/syscall/precompiles/blake2s/mod.rs | 185 ++++++++++++++++++++
 core/src/syscall/precompiles/mod.rs         |   1 +
 zkvm/entrypoint/src/syscalls/mod.rs         |   2 +
 6 files changed, 223 insertions(+)
 create mode 100644 core/src/syscall/precompiles/blake2s/mod.rs

diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index d21c7c28c..7fc240c53 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -10,6 +10,7 @@ use super::{program::Program, Opcode};
 use crate::runtime::MemoryInitializeFinalizeEvent;
 use crate::runtime::MemoryRecordEnum;
 use crate::stark::MachineRecord;
+use crate::syscall::precompiles::blake2s::{EmptyChip, EmptyEvent};
 use crate::syscall::precompiles::edwards::EdDecompressEvent;
 use crate::syscall::precompiles::keccak256::KeccakPermuteEvent;
 use crate::syscall::precompiles::sha256::{ShaCompressEvent, ShaExtendEvent};
@@ -96,6 +97,8 @@ pub struct ExecutionRecord {
 
     pub sha_extend_events: Vec<ShaExtendEvent>,
 
+    pub empty_events: Vec<EmptyEvent>,
+
     pub sha_compress_events: Vec<ShaCompressEvent>,
 
     pub keccak_permute_events: Vec<KeccakPermuteEvent>,
@@ -214,6 +217,12 @@ impl EventLens<ShaExtendChip> for ExecutionRecord {
     }
 }
 
+impl EventLens<EmptyChip> for ExecutionRecord {
+    fn events(&self) -> <EmptyChip as crate::air::WithEvents<'_>>::Events {
+        &self.empty_events
+    }
+}
+
 impl EventLens<ShaCompressChip> for ExecutionRecord {
     fn events(&self) -> <ShaCompressChip as crate::air::WithEvents<'_>>::Events {
         &self.sha_compress_events
@@ -411,6 +420,7 @@ impl MachineRecord for ExecutionRecord {
             "sha_compress_events".to_string(),
             self.sha_compress_events.len(),
         );
+        stats.insert("empty_events".to_string(), self.empty_events.len());
         stats.insert(
             "keccak_permute_events".to_string(),
             self.keccak_permute_events.len(),
@@ -482,6 +492,9 @@ impl MachineRecord for ExecutionRecord {
         self.sha_extend_events.append(&mut other.sha_extend_events);
         self.sha_compress_events
             .append(&mut other.sha_compress_events);
+
+        self.empty_events.append(&mut other.empty_events);
+
         self.keccak_permute_events
             .append(&mut other.keccak_permute_events);
         self.ed_add_events.append(&mut other.ed_add_events);
@@ -795,6 +808,12 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, (i * 48) as u32);
         }
 
+        // Empty events
+        first.empty_events = take(&mut self.empty_events);
+        for (i, event) in first.empty_events.iter().enumerate() {
+            self.nonce_lookup.insert(event.lookup_id, (i * 48) as u32);
+        }
+
         // SHA-256 compress events.
         first.sha_compress_events = take(&mut self.sha_compress_events);
         for (i, event) in first.sha_compress_events.iter().enumerate() {
diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 8b6c68e59..370b96033 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -6,6 +6,7 @@ use strum_macros::EnumIter;
 
 use crate::runtime::{Register, Runtime};
 use crate::stark::Ed25519Parameters;
+use crate::syscall::precompiles::blake2s::EmptyChip;
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::bls12_381::g2_add::Bls12381G2AffineAddChip;
 use crate::syscall::precompiles::bls12_381::g2_double::Bls12381G2AffineDoubleChip;
@@ -116,6 +117,8 @@ pub enum SyscallCode {
 
     /// Executes the `HINT_READ` precompile.
     HINT_READ = 0x00_00_00_F1,
+
+    EMPTY = 0x00_00_01_CC,
 }
 
 impl SyscallCode {
@@ -152,6 +155,7 @@ impl SyscallCode {
             0x00_01_01_F2 => SyscallCode::BLS12381_G1_DECOMPRESS,
             0x00_01_01_80 => SyscallCode::BLS12381_G2_ADD,
             0x00_00_01_81 => SyscallCode::BLS12381_G2_DOUBLE,
+            0x00_00_01_CC => SyscallCode::EMPTY,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -390,6 +394,8 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
         Arc::new(Bls12381G2AffineDoubleChip::new()),
     );
 
+    syscall_map.insert(SyscallCode::EMPTY, Arc::new(EmptyChip::new()));
+
     syscall_map
 }
 
@@ -503,6 +509,10 @@ mod tests {
                 SyscallCode::BLS12381_G2_DOUBLE => {
                     assert_eq!(code as u32, sphinx_zkvm::syscalls::BLS12381_G2_DOUBLE)
                 }
+
+                SyscallCode::EMPTY => {
+                    assert_eq!(code as u32, sphinx_zkvm::syscalls::EMPTY)
+                }
             }
         }
     }
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index 7a2f08c46..5cdeec2e3 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -3,6 +3,7 @@ pub use crate::air::SphinxAirBuilder;
 use crate::air::{MachineAir, SPHINX_PROOF_NUM_PV_ELTS};
 use crate::memory::{MemoryChipType, MemoryProgramChip};
 use crate::stark::Chip;
+use crate::syscall::precompiles::blake2s::EmptyChip;
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::field::FieldChip;
 use crate::syscall::precompiles::quad_field::QuadFieldChip;
@@ -106,6 +107,8 @@ pub enum RiscvAir<F: PrimeField32> {
     Bls12381Fp2Op(QuadFieldChip<Bls12381BaseField>),
     /// A precompile for decompressing a point on the BLS12-381 curve.
     Bls12381G1Decompress(Bls12381G1DecompressChip),
+
+    Empty(EmptyChip),
 }
 
 impl<F: PrimeField32> RiscvAir<F> {
@@ -182,6 +185,9 @@ impl<F: PrimeField32> RiscvAir<F> {
         let byte = ByteChip::default();
         chips.push(RiscvAir::ByteLookup(byte));
 
+        let empty = EmptyChip::default();
+        chips.push(RiscvAir::Empty(empty));
+
         chips
     }
 }
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
new file mode 100644
index 000000000..928117cc9
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -0,0 +1,185 @@
+use crate::stark::SphinxAirBuilder;
+use crate::utils::pad_rows;
+use crate::{
+    air::{EventLens, MachineAir, WithEvents},
+    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
+};
+use core::borrow::{Borrow, BorrowMut};
+use p3_air::{Air, AirBuilder, BaseAir};
+use p3_field::{AbstractField, PrimeField32};
+use p3_matrix::dense::RowMajorMatrix;
+use p3_matrix::Matrix;
+use serde::Deserialize;
+use serde::Serialize;
+use sphinx_derive::AlignedBorrow;
+use std::mem::size_of;
+
+#[derive(Default)]
+pub struct EmptyChip;
+
+impl EmptyChip {
+    pub fn new() -> Self {
+        EmptyChip
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EmptyEvent {
+    pub lookup_id: usize,
+    pub clk: u32,
+    pub shard: u32,
+    pub channel: u32,
+}
+
+impl Syscall for EmptyChip {
+    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, _arg1: u32, _arg2: u32) -> Option<u32> {
+        let clk = ctx.clk;
+        let shard = ctx.current_shard();
+        let lookup_id = ctx.syscall_lookup_id;
+        let channel = ctx.current_channel();
+
+        ctx.record_mut().empty_events.push(EmptyEvent {
+            lookup_id,
+            clk,
+            shard,
+            channel,
+        });
+
+        None
+    }
+}
+
+#[derive(Debug, Clone, AlignedBorrow)]
+#[repr(C)]
+struct EmptyCols<T> {
+    pub clk: T,
+    pub shard: T,
+    pub channel: T,
+    pub nonce: T,
+    pub is_real: T,
+
+    pub a: T,
+}
+
+impl<T: PrimeField32> BaseAir<T> for EmptyChip {
+    fn width(&self) -> usize {
+        size_of::<EmptyCols<u8>>()
+    }
+}
+
+impl<'a> WithEvents<'a> for EmptyChip {
+    type Events = &'a [EmptyEvent];
+}
+
+impl<F: PrimeField32> MachineAir<F> for EmptyChip {
+    type Record = ExecutionRecord;
+    type Program = Program;
+
+    fn name(&self) -> String {
+        "EmptyChip".to_string()
+    }
+
+    fn generate_trace<EL: EventLens<Self>>(
+        &self,
+        input: &EL,
+        _output: &mut Self::Record,
+    ) -> RowMajorMatrix<F> {
+        let mut rows = vec![];
+
+        let width = <EmptyChip as BaseAir<F>>::width(self);
+
+        for event in input.events() {
+            let mut row = vec![F::zero(); width];
+            let cols: &mut EmptyCols<F> = row.as_mut_slice().borrow_mut();
+            cols.clk = F::from_canonical_u32(event.clk);
+            cols.is_real = F::one();
+            cols.shard = F::from_canonical_u32(event.shard);
+            cols.channel = F::from_canonical_u32(event.channel);
+
+            cols.a = F::from_canonical_u32(100500u32);
+
+            rows.push(row);
+        }
+
+        pad_rows(&mut rows, || {
+            let row = vec![F::zero(); width];
+
+            row
+        });
+
+        let mut trace =
+            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
+
+        // Write the nonces to the trace.
+        for i in 0..trace.height() {
+            let cols: &mut EmptyCols<F> = trace.values[i * width..(i + 1) * width].borrow_mut();
+            cols.nonce = F::from_canonical_usize(i);
+        }
+
+        trace
+    }
+
+    fn included(&self, shard: &Self::Record) -> bool {
+        !shard.empty_events.is_empty()
+    }
+}
+
+impl<AB: SphinxAirBuilder> Air<AB> for EmptyChip
+where
+    AB::F: PrimeField32,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local = main.row_slice(0);
+        let next = main.row_slice(1);
+        let local: &EmptyCols<AB::Var> = (*local).borrow();
+        let next: &EmptyCols<AB::Var> = (*next).borrow();
+
+        // Constrain the incrementing nonce.
+        builder.when_first_row().assert_zero(local.nonce);
+        builder
+            .when_transition()
+            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
+
+        builder.receive_syscall(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.nonce,
+            AB::F::from_canonical_u32(SyscallCode::EMPTY.syscall_id()),
+            AB::Expr::zero(),
+            AB::Expr::zero(),
+            local.is_real,
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::runtime::{Instruction, Opcode, SyscallCode};
+    use crate::utils::{run_test, setup_logger};
+    use crate::Program;
+
+    fn risc_v_program() -> Program {
+        let mut instructions = vec![];
+        instructions.push(Instruction::new(
+            Opcode::ADD,
+            5,
+            0,
+            SyscallCode::EMPTY as u32,
+            false,
+            true,
+        ));
+        instructions.push(Instruction::new(Opcode::ADD, 10, 0, 0, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 11, 0, 0, false, true));
+        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
+        Program::new(instructions, 0, 0)
+    }
+
+    #[test]
+    fn test_empty_precompile() {
+        setup_logger();
+        let program = risc_v_program();
+        run_test(program).unwrap();
+    }
+}
diff --git a/core/src/syscall/precompiles/mod.rs b/core/src/syscall/precompiles/mod.rs
index d85d25e4b..4d4757af1 100644
--- a/core/src/syscall/precompiles/mod.rs
+++ b/core/src/syscall/precompiles/mod.rs
@@ -1,3 +1,4 @@
+pub mod blake2s;
 pub mod bls12_381;
 pub mod edwards;
 pub mod field;
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 206f68c97..a7f4993e9 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -106,3 +106,5 @@ pub const BLS12381_G1_DOUBLE: u32 = 0x00_00_01_72;
 
 /// Executes `BLS12381_G1_DECOMPRESS`.
 pub const BLS12381_G1_DECOMPRESS: u32 = 0x00_01_01_F2;
+
+pub const EMPTY: u32 = 0x00_00_01_CC;

From c02b2001acf7c2ffc574cb826d5e2cdd60c4951b Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Tue, 10 Sep 2024 17:37:52 +0300
Subject: [PATCH 02/30] chore: working XOR operation

---
 core/src/syscall/precompiles/blake2s/mod.rs | 381 +++++++++++++++++++-
 1 file changed, 367 insertions(+), 14 deletions(-)

diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 928117cc9..2666cf8f7 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -13,6 +13,10 @@ use serde::Deserialize;
 use serde::Serialize;
 use sphinx_derive::AlignedBorrow;
 use std::mem::size_of;
+use crate::bytes::event::ByteRecord;
+use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
+use crate::operations::XorOperation;
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
 
 #[derive(Default)]
 pub struct EmptyChip;
@@ -29,20 +33,54 @@ pub struct EmptyEvent {
     pub clk: u32,
     pub shard: u32,
     pub channel: u32,
+    pub a_ptr: u32,
+    pub b_ptr: u32,
+    pub a_reads: Vec<MemoryReadRecord>,
+    pub b_reads: Vec<MemoryReadRecord>,
+    //pub xor_writes: Vec<MemoryWriteRecord>,
 }
 
 impl Syscall for EmptyChip {
-    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, _arg1: u32, _arg2: u32) -> Option<u32> {
-        let clk = ctx.clk;
+    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
+        let clk_init = ctx.clk;
         let shard = ctx.current_shard();
         let lookup_id = ctx.syscall_lookup_id;
         let channel = ctx.current_channel();
 
+        let a_ptr = arg1;
+        let a_ptr_init = a_ptr;
+        let b_ptr = arg2;
+        let b_ptr_init = b_ptr;
+
+        let mut a_reads = Vec::new();
+        let mut b_reads = Vec::new();
+
+        // Read a0.
+        let (record, a) = ctx.mr(a_ptr);
+        a_reads.push(record);
+
+        // Read b0.
+        let (record, b) = ctx.mr(b_ptr);
+        b_reads.push(record);
+
+        // compute a ^ b xor
+        let _xor = a ^ b;
+
+        // Write xor to a_ptr.
+        //xor_writes.push(ctx.mw(a_ptr, xor0));
+        //ctx.clk += 1;
+
+
         ctx.record_mut().empty_events.push(EmptyEvent {
             lookup_id,
-            clk,
+            clk: clk_init,
             shard,
             channel,
+            a_ptr: a_ptr_init,
+            b_ptr: b_ptr_init,
+            a_reads,
+            b_reads,
+            //xor_writes: xor0_writes,
         });
 
         None
@@ -58,7 +96,13 @@ struct EmptyCols<T> {
     pub nonce: T,
     pub is_real: T,
 
-    pub a: T,
+    pub a_ptr: T,
+    pub b_ptr: T,
+
+    pub a0: MemoryReadCols<T>,
+    pub b0: MemoryReadCols<T>,
+    pub xor0: XorOperation<T>,
+    //pub axorb: MemoryWriteCols<T>,
 }
 
 impl<T: PrimeField32> BaseAir<T> for EmptyChip {
@@ -82,25 +126,58 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
     fn generate_trace<EL: EventLens<Self>>(
         &self,
         input: &EL,
-        _output: &mut Self::Record,
+        output: &mut Self::Record,
     ) -> RowMajorMatrix<F> {
         let mut rows = vec![];
-
         let width = <EmptyChip as BaseAir<F>>::width(self);
-
+        let mut new_byte_lookup_events = Vec::new();
         for event in input.events() {
+            let shard = event.shard;
             let mut row = vec![F::zero(); width];
             let cols: &mut EmptyCols<F> = row.as_mut_slice().borrow_mut();
+
             cols.clk = F::from_canonical_u32(event.clk);
             cols.is_real = F::one();
             cols.shard = F::from_canonical_u32(event.shard);
             cols.channel = F::from_canonical_u32(event.channel);
+            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
+            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
+
+            cols.a0.populate(
+                event.channel,
+                event.a_reads[0],
+                &mut new_byte_lookup_events,
+            );
+
+            cols.b0.populate(
+                event.channel,
+                event.b_reads[0],
+                &mut new_byte_lookup_events,
+            );
 
-            cols.a = F::from_canonical_u32(100500u32);
+            let a0 = event.a_reads[0].value;
+            let b0 = event.b_reads[0].value;
+            let xor0 = cols.xor0.populate(
+                output,
+                shard,
+                event.channel,
+                a0,
+                b0,
+            );
+
+            assert_eq!(a0 ^ b0, xor0);
+
+            //cols.axorb0.populate(
+            //    event.channel,
+            //    event.xor_writes[0],
+            //    &mut new_byte_lookup_events,
+            //);
 
             rows.push(row);
         }
 
+        output.add_byte_lookup_events(new_byte_lookup_events);
+
         pad_rows(&mut rows, || {
             let row = vec![F::zero(); width];
 
@@ -117,6 +194,7 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
         }
 
         trace
+
     }
 
     fn included(&self, shard: &Self::Record) -> bool {
@@ -141,14 +219,56 @@ where
             .when_transition()
             .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
 
+        // Read a.
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.a_ptr,
+            &local.a0,
+            local.is_real,
+        );
+
+        // Read b.
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.b_ptr,
+            &local.b0,
+            local.is_real,
+        );
+
+        // XOR
+        XorOperation::<AB::F>::eval(
+            builder,
+            *local.a0.value(),
+            *local.b0.value(),
+            local.xor0,
+            local.shard,
+            &local.channel,
+            local.is_real,
+        );
+
+        // Write XOR to memory.
+        //builder.eval_memory_access(
+        //    local.shard,
+        //    local.channel,
+        //    local.clk,
+        //    local.a_ptr,
+        //    &local.a0,
+        //    local.is_real,
+        //);
+        //builder.assert_word_eq(*local.a0.value(), local.xor0.value);
+
         builder.receive_syscall(
             local.shard,
             local.channel,
             local.clk,
             local.nonce,
             AB::F::from_canonical_u32(SyscallCode::EMPTY.syscall_id()),
-            AB::Expr::zero(),
-            AB::Expr::zero(),
+            local.a_ptr,
+            local.b_ptr,
             local.is_real,
         )
     }
@@ -160,8 +280,38 @@ mod tests {
     use crate::utils::{run_test, setup_logger};
     use crate::Program;
 
-    fn risc_v_program() -> Program {
+    fn risc_v_program(a: [u32; 4], b: [u32; 4]) -> Program {
+        let a_ptr = 100100100;
+        let b_ptr = 200200200;
+
         let mut instructions = vec![];
+
+        //for (index, word) in a_words.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, a[0], false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                a_ptr + (0 * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        //}
+
+        //for (index, word) in b_words.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, b[0], false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                b_ptr + (0 * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        //}
+
         instructions.push(Instruction::new(
             Opcode::ADD,
             5,
@@ -170,8 +320,8 @@ mod tests {
             false,
             true,
         ));
-        instructions.push(Instruction::new(Opcode::ADD, 10, 0, 0, false, true));
-        instructions.push(Instruction::new(Opcode::ADD, 11, 0, 0, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
         instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
         Program::new(instructions, 0, 0)
     }
@@ -179,7 +329,210 @@ mod tests {
     #[test]
     fn test_empty_precompile() {
         setup_logger();
-        let program = risc_v_program();
+        let program = risc_v_program(
+            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+        );
         run_test(program).unwrap();
     }
+
+    fn xor_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
+        [
+            a[0] ^ b[0],
+            a[1] ^ b[1],
+            a[2] ^ b[2],
+            a[3] ^ b[3],
+        ]
+    }
+
+
+
+
+
+
+
+
+
+
+
+    fn shuffle_left_1_u32x4(a: [u32; 4]) -> [u32; 4] {
+        [a[1], a[2], a[3], a[0]]
+    }
+
+    fn shuffle_left_2_u32x4(a: [u32; 4]) -> [u32; 4] {
+        [a[2], a[3], a[0], a[1]]
+    }
+
+    fn shuffle_left_3_u32x4(a: [u32; 4]) -> [u32; 4] {
+        [a[3], a[0], a[1], a[2]]
+    }
+
+    fn shuffle_right_1_u32x4(a: [u32; 4]) -> [u32; 4] {
+        shuffle_left_3_u32x4(a)
+    }
+    fn shuffle_right_2_u32x4(a: [u32; 4]) -> [u32; 4] {
+        shuffle_left_2_u32x4(a)
+    }
+    fn shuffle_right_3_u32x4(a: [u32; 4]) -> [u32; 4] {
+        shuffle_left_1_u32x4(a)
+    }
+
+    fn wrapping_add_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
+        [
+            a[0].wrapping_add(b[0]),
+            a[1].wrapping_add(b[1]),
+            a[2].wrapping_add(b[2]),
+            a[3].wrapping_add(b[3])
+        ]
+    }
+
+    fn rotate_right_const(a: [u32; 4], n: u32) -> [u32; 4] {
+        [
+            a[0].rotate_right(n),
+            a[1].rotate_right(n),
+            a[2].rotate_right(n),
+            a[3].rotate_right(n),
+        ]
+    }
+
+    fn quarter_round(v: &mut Vec<[u32; 4]>, rd: u32, rb: u32, m: [u32; 4]) {
+        v[0] = wrapping_add_u32x4(wrapping_add_u32x4(v[0], v[1]), m); // m.from_le (?)
+        v[3] = rotate_right_const(xor_u32x4(v[3], v[0]), rd);
+        v[2] = wrapping_add_u32x4(v[2], v[3]);
+        v[1] = rotate_right_const(xor_u32x4(v[1], v[2]), rb);
+    }
+
+    fn shuffle(v: &mut Vec<[u32; 4]>) {
+        v[1] = shuffle_left_1_u32x4(v[1]);
+        v[2] = shuffle_left_2_u32x4(v[2]);
+        v[3] = shuffle_left_3_u32x4(v[3]);
+    }
+
+    fn unshuffle(v: &mut Vec<[u32; 4]>) {
+        v[1] = shuffle_right_1_u32x4(v[1]);
+        v[2] = shuffle_right_2_u32x4(v[2]);
+        v[3] = shuffle_right_3_u32x4(v[3]);
+    }
+
+    fn gather(m: [u32; 16], i0: usize, i1: usize, i2: usize, i3: usize) -> [u32; 4]{
+        [
+            m[i0],
+            m[i1],
+            m[i2],
+            m[i3]
+        ]
+    }
+
+    fn round(v: &mut Vec<[u32; 4]>, m: [u32; 16], s: [usize; 16]) {
+        let r1 = 16;
+        let r2 = 12;
+        let r3 = 8;
+        let r4 = 7;
+
+        quarter_round(v, r1, r2, gather(m, s[0], s[2], s[4], s[6]));
+        quarter_round(v, r3, r4, gather(m, s[1], s[3], s[5], s[7]));
+        shuffle(v);
+        quarter_round(v, r1, r2, gather(m, s[8], s[10], s[12], s[14]));
+        quarter_round(v, r3, r4, gather(m, s[9], s[11], s[13], s[15]));
+        unshuffle(v);
+    }
+
+    #[test]
+    fn test_blake2s_round_function() {
+        fn test_inner(input: &mut Vec<[u32; 4]>, m: [u32; 16], s: [usize; 16], output: Vec<[u32; 4]>) {
+            round(input, m, s);
+            assert_eq!(input.clone(), output);
+        }
+
+        let mut v: Vec<[u32; 4]> = vec![
+            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+            [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0xe07c2654, 0x5be0cd19],
+        ];
+
+        let m: [u32; 16] = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+        let s: [usize; 16] = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f];
+
+        test_inner(&mut v, m, s, vec![
+                [0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3],
+                [0x515f5af4, 0x0301095b, 0xb151a3c2, 0x5e17f96f],
+                [0xc561666d, 0x0f291605, 0x990c6d13, 0x76fff6f1],
+                [0x1e53bf19, 0x6fe4a680, 0x08e33663, 0x97fd885e],
+        ]);
+
+
+        let mut v: Vec<[u32; 4]> = vec![
+            [0x01, 0x01, 0x01, 0x01],
+            [0x01, 0x01, 0x01, 0x01],
+            [0x01, 0x01, 0x01, 0x01],
+            [0x01, 0x01, 0x01, 0x01],
+        ];
+
+        let m: [u32; 16] = [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01];
+        let s: [usize; 16] = [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01];
+
+        test_inner(&mut v, m, s, vec![
+            [0x071e8a60, 0x071e8a60, 0x071e8a60, 0x071e8a60],
+            [0x072df44c, 0x072df44c, 0x072df44c, 0x072df44c],
+            [0x522ca035, 0x522ca035, 0x522ca035, 0x522ca035],
+            [0x280137ec, 0x280137ec, 0x280137ec, 0x280137ec]
+        ]);
+    }
+
+    #[test]
+    fn test_blake2s_unshuffle_function() {
+        let mut v: Vec<[u32; 4]> = vec![
+            [0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3],
+            [0x0301095b, 0xb151a3c2, 0x5e17f96f, 0x515f5af4],
+            [0x990c6d13, 0x76fff6f1, 0xc561666d, 0x0f291605],
+            [0x97fd885e, 0x1e53bf19, 0x6fe4a680, 0x08e33663],
+        ];
+
+        unshuffle(&mut v);
+
+        assert_eq!(v[0].to_vec(), vec![0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3]);
+        assert_eq!(v[1].to_vec(), vec![0x515f5af4, 0x0301095b, 0xb151a3c2, 0x5e17f96f]);
+        assert_eq!(v[2].to_vec(), vec![0xc561666d, 0x0f291605, 0x990c6d13, 0x76fff6f1]);
+        assert_eq!(v[3].to_vec(), vec![0x1e53bf19, 0x6fe4a680, 0x08e33663, 0x97fd885e]);
+
+    }
+
+    #[test]
+    fn test_blake2s_shuffle_function() {
+        let mut v: Vec<[u32; 4]> = vec![
+            [0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc],
+            [0x408705aa, 0x8d07c52d, 0xb9d6aa3a, 0x88609304],
+            [0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed],
+            [0x87b6b678, 0x7af31ada, 0x5a2defeb, 0x2cdd25e3],
+        ];
+
+        shuffle(&mut v);
+
+        assert_eq!(v[0].to_vec(), vec![0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc]);
+        assert_eq!(v[1].to_vec(), vec![0x8d07c52d, 0xb9d6aa3a, 0x88609304, 0x408705aa]);
+        assert_eq!(v[2].to_vec(), vec![0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7]);
+        assert_eq!(v[3].to_vec(), vec![0x2cdd25e3, 0x87b6b678, 0x7af31ada, 0x5a2defeb]);
+
+    }
+
+    #[test]
+    fn test_blake2s_quarter_round_function() {
+        let mut v: Vec<[u32; 4]> = vec![
+            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+            [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0xe07c2654, 0x5be0cd19],
+        ];
+        let m = [0, 0, 0, 0];
+        let rd = 16;
+        let rb = 12;
+
+        quarter_round(&mut v, rd, rb, m);
+
+        assert_eq!(v[0].to_vec(), vec![0xbc1738c6, 0x566d1711, 0x5bf2cd1d, 0x130c253]);
+        assert_eq!(v[1].to_vec(), vec![0x1ff85cd8, 0x361a0001, 0x6ab383b7, 0xd13ef7a9]);
+        assert_eq!(v[2].to_vec(), vec![0xd4c3d380, 0x3b057bed, 0x27b8af00, 0xb49a500a]);
+        assert_eq!(v[3].to_vec(), vec![0x6ab9ed19, 0x7f9dcd68, 0xeb49bb8e, 0xf4a5ad0]);
+    }
 }

From 734909cd32dcd0d85e5504385d80ed7de8c53e4d Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Tue, 10 Sep 2024 19:43:33 +0300
Subject: [PATCH 03/30] chore: Fix event's lookup_id insertion to nonce_lookup

---
 core/src/runtime/record.rs | 2 +-
 core/src/utils/prove.rs    | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index 7fc240c53..28acd247b 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -811,7 +811,7 @@ impl MachineRecord for ExecutionRecord {
         // Empty events
         first.empty_events = take(&mut self.empty_events);
         for (i, event) in first.empty_events.iter().enumerate() {
-            self.nonce_lookup.insert(event.lookup_id, (i * 48) as u32);
+            self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
         // SHA-256 compress events.
diff --git a/core/src/utils/prove.rs b/core/src/utils/prove.rs
index dee783732..84be69a52 100644
--- a/core/src/utils/prove.rs
+++ b/core/src/utils/prove.rs
@@ -356,11 +356,11 @@ where
     OpeningProof<SC>: Send + Sync,
     ShardMainData<SC>: Serialize + DeserializeOwned,
 {
-    #[cfg(debug_assertions)]
-    {
+    //#[cfg(debug_assertions)]
+    //{
         let record_clone = record.clone();
         machine.debug_constraints(pk, record_clone);
-    }
+    //}
     let stats = record.stats().clone();
     let cycles = stats.get("cpu_events").unwrap();
 

From f6516d5166a31a2258966c135140b4cf988fe131 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Wed, 11 Sep 2024 16:19:28 +0300
Subject: [PATCH 04/30] chore: Working XOR operation for 4 u32 words

---
 core/src/syscall/precompiles/blake2s/mod.rs | 290 +++++++++++---------
 core/src/utils/prove.rs                     |   4 +-
 2 files changed, 162 insertions(+), 132 deletions(-)

diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 2666cf8f7..7faae1447 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -1,3 +1,7 @@
+use crate::bytes::event::ByteRecord;
+use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
+use crate::operations::XorOperation;
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
 use crate::stark::SphinxAirBuilder;
 use crate::utils::pad_rows;
 use crate::{
@@ -13,10 +17,6 @@ use serde::Deserialize;
 use serde::Serialize;
 use sphinx_derive::AlignedBorrow;
 use std::mem::size_of;
-use crate::bytes::event::ByteRecord;
-use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::XorOperation;
-use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
 
 #[derive(Default)]
 pub struct EmptyChip;
@@ -48,36 +48,34 @@ impl Syscall for EmptyChip {
         let channel = ctx.current_channel();
 
         let a_ptr = arg1;
-        let a_ptr_init = a_ptr;
         let b_ptr = arg2;
-        let b_ptr_init = b_ptr;
 
         let mut a_reads = Vec::new();
         let mut b_reads = Vec::new();
 
-        // Read a0.
-        let (record, a) = ctx.mr(a_ptr);
-        a_reads.push(record);
+        for i in 0..4usize {
+            // Read a.
+            let (record, a) = ctx.mr(a_ptr + (i * 4) as u32);
+            a_reads.push(record);
 
-        // Read b0.
-        let (record, b) = ctx.mr(b_ptr);
-        b_reads.push(record);
+            // Read b.
+            let (record, b) = ctx.mr(b_ptr + (i * 4) as u32);
+            b_reads.push(record);
 
-        // compute a ^ b xor
-        let _xor = a ^ b;
+            let _xor = a ^ b;
+        }
 
         // Write xor to a_ptr.
         //xor_writes.push(ctx.mw(a_ptr, xor0));
         //ctx.clk += 1;
 
-
         ctx.record_mut().empty_events.push(EmptyEvent {
             lookup_id,
             clk: clk_init,
             shard,
             channel,
-            a_ptr: a_ptr_init,
-            b_ptr: b_ptr_init,
+            a_ptr,
+            b_ptr,
             a_reads,
             b_reads,
             //xor_writes: xor0_writes,
@@ -99,9 +97,10 @@ struct EmptyCols<T> {
     pub a_ptr: T,
     pub b_ptr: T,
 
-    pub a0: MemoryReadCols<T>,
-    pub b0: MemoryReadCols<T>,
-    pub xor0: XorOperation<T>,
+    pub a: [MemoryReadCols<T>; 4],
+    pub b: [MemoryReadCols<T>; 4],
+
+    pub xor: [XorOperation<T>; 4],
     //pub axorb: MemoryWriteCols<T>,
 }
 
@@ -143,29 +142,16 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
             cols.a_ptr = F::from_canonical_u32(event.a_ptr);
             cols.b_ptr = F::from_canonical_u32(event.b_ptr);
 
-            cols.a0.populate(
-                event.channel,
-                event.a_reads[0],
-                &mut new_byte_lookup_events,
-            );
+            for i in 0..4usize {
+                cols.a[i].populate(event.channel, event.a_reads[i], &mut new_byte_lookup_events);
 
-            cols.b0.populate(
-                event.channel,
-                event.b_reads[0],
-                &mut new_byte_lookup_events,
-            );
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
 
-            let a0 = event.a_reads[0].value;
-            let b0 = event.b_reads[0].value;
-            let xor0 = cols.xor0.populate(
-                output,
-                shard,
-                event.channel,
-                a0,
-                b0,
-            );
-
-            assert_eq!(a0 ^ b0, xor0);
+                let a = event.a_reads[i].value;
+                let b = event.b_reads[i].value;
+                let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
+                assert_eq!(a ^ b, xor);
+            }
 
             //cols.axorb0.populate(
             //    event.channel,
@@ -194,7 +180,6 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
         }
 
         trace
-
     }
 
     fn included(&self, shard: &Self::Record) -> bool {
@@ -219,36 +204,38 @@ where
             .when_transition()
             .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
 
-        // Read a.
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.a_ptr,
-            &local.a0,
-            local.is_real,
-        );
+        for i in 0..4usize {
+            // Read a.
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.a[i],
+                local.is_real,
+            );
 
-        // Read b.
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.b_ptr,
-            &local.b0,
-            local.is_real,
-        );
+            // Read b.
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
 
-        // XOR
-        XorOperation::<AB::F>::eval(
-            builder,
-            *local.a0.value(),
-            *local.b0.value(),
-            local.xor0,
-            local.shard,
-            &local.channel,
-            local.is_real,
-        );
+            // XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i].value(),
+                *local.b[i].value(),
+                local.xor[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+        }
 
         // Write XOR to memory.
         //builder.eval_memory_access(
@@ -286,32 +273,35 @@ mod tests {
 
         let mut instructions = vec![];
 
-        //for (index, word) in a_words.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, a[0], false, true));
+        // memory write a
+        for (index, word) in a.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
             instructions.push(Instruction::new(
                 Opcode::ADD,
                 30,
                 0,
-                a_ptr + (0 * 4) as u32,
+                a_ptr + (index * 4) as u32,
                 false,
                 true,
             ));
             instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        //}
+        }
 
-        //for (index, word) in b_words.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, b[0], false, true));
+        // memory write b
+        for (index, word) in b.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
             instructions.push(Instruction::new(
                 Opcode::ADD,
                 30,
                 0,
-                b_ptr + (0 * 4) as u32,
+                b_ptr + (index * 4) as u32,
                 false,
                 true,
             ));
             instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        //}
+        }
 
+        // Syscall invocation
         instructions.push(Instruction::new(
             Opcode::ADD,
             5,
@@ -337,24 +327,9 @@ mod tests {
     }
 
     fn xor_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
-        [
-            a[0] ^ b[0],
-            a[1] ^ b[1],
-            a[2] ^ b[2],
-            a[3] ^ b[3],
-        ]
+        [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]]
     }
 
-
-
-
-
-
-
-
-
-
-
     fn shuffle_left_1_u32x4(a: [u32; 4]) -> [u32; 4] {
         [a[1], a[2], a[3], a[0]]
     }
@@ -382,7 +357,7 @@ mod tests {
             a[0].wrapping_add(b[0]),
             a[1].wrapping_add(b[1]),
             a[2].wrapping_add(b[2]),
-            a[3].wrapping_add(b[3])
+            a[3].wrapping_add(b[3]),
         ]
     }
 
@@ -414,13 +389,8 @@ mod tests {
         v[3] = shuffle_right_3_u32x4(v[3]);
     }
 
-    fn gather(m: [u32; 16], i0: usize, i1: usize, i2: usize, i3: usize) -> [u32; 4]{
-        [
-            m[i0],
-            m[i1],
-            m[i2],
-            m[i3]
-        ]
+    fn gather(m: [u32; 16], i0: usize, i1: usize, i2: usize, i3: usize) -> [u32; 4] {
+        [m[i0], m[i1], m[i2], m[i3]]
     }
 
     fn round(v: &mut Vec<[u32; 4]>, m: [u32; 16], s: [usize; 16]) {
@@ -439,7 +409,12 @@ mod tests {
 
     #[test]
     fn test_blake2s_round_function() {
-        fn test_inner(input: &mut Vec<[u32; 4]>, m: [u32; 16], s: [usize; 16], output: Vec<[u32; 4]>) {
+        fn test_inner(
+            input: &mut Vec<[u32; 4]>,
+            m: [u32; 16],
+            s: [usize; 16],
+            output: Vec<[u32; 4]>,
+        ) {
             round(input, m, s);
             assert_eq!(input.clone(), output);
         }
@@ -451,16 +426,26 @@ mod tests {
             [0x510e527f, 0x9b05688c, 0xe07c2654, 0x5be0cd19],
         ];
 
-        let m: [u32; 16] = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
-        let s: [usize; 16] = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f];
+        let m: [u32; 16] = [
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00,
+        ];
+        let s: [usize; 16] = [
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+            0x0e, 0x0f,
+        ];
 
-        test_inner(&mut v, m, s, vec![
+        test_inner(
+            &mut v,
+            m,
+            s,
+            vec![
                 [0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3],
                 [0x515f5af4, 0x0301095b, 0xb151a3c2, 0x5e17f96f],
                 [0xc561666d, 0x0f291605, 0x990c6d13, 0x76fff6f1],
                 [0x1e53bf19, 0x6fe4a680, 0x08e33663, 0x97fd885e],
-        ]);
-
+            ],
+        );
 
         let mut v: Vec<[u32; 4]> = vec![
             [0x01, 0x01, 0x01, 0x01],
@@ -469,15 +454,26 @@ mod tests {
             [0x01, 0x01, 0x01, 0x01],
         ];
 
-        let m: [u32; 16] = [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01];
-        let s: [usize; 16] = [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01];
+        let m: [u32; 16] = [
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01,
+        ];
+        let s: [usize; 16] = [
+            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+            0x01, 0x01,
+        ];
 
-        test_inner(&mut v, m, s, vec![
-            [0x071e8a60, 0x071e8a60, 0x071e8a60, 0x071e8a60],
-            [0x072df44c, 0x072df44c, 0x072df44c, 0x072df44c],
-            [0x522ca035, 0x522ca035, 0x522ca035, 0x522ca035],
-            [0x280137ec, 0x280137ec, 0x280137ec, 0x280137ec]
-        ]);
+        test_inner(
+            &mut v,
+            m,
+            s,
+            vec![
+                [0x071e8a60, 0x071e8a60, 0x071e8a60, 0x071e8a60],
+                [0x072df44c, 0x072df44c, 0x072df44c, 0x072df44c],
+                [0x522ca035, 0x522ca035, 0x522ca035, 0x522ca035],
+                [0x280137ec, 0x280137ec, 0x280137ec, 0x280137ec],
+            ],
+        );
     }
 
     #[test]
@@ -491,11 +487,22 @@ mod tests {
 
         unshuffle(&mut v);
 
-        assert_eq!(v[0].to_vec(), vec![0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3]);
-        assert_eq!(v[1].to_vec(), vec![0x515f5af4, 0x0301095b, 0xb151a3c2, 0x5e17f96f]);
-        assert_eq!(v[2].to_vec(), vec![0xc561666d, 0x0f291605, 0x990c6d13, 0x76fff6f1]);
-        assert_eq!(v[3].to_vec(), vec![0x1e53bf19, 0x6fe4a680, 0x08e33663, 0x97fd885e]);
-
+        assert_eq!(
+            v[0].to_vec(),
+            vec![0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3]
+        );
+        assert_eq!(
+            v[1].to_vec(),
+            vec![0x515f5af4, 0x0301095b, 0xb151a3c2, 0x5e17f96f]
+        );
+        assert_eq!(
+            v[2].to_vec(),
+            vec![0xc561666d, 0x0f291605, 0x990c6d13, 0x76fff6f1]
+        );
+        assert_eq!(
+            v[3].to_vec(),
+            vec![0x1e53bf19, 0x6fe4a680, 0x08e33663, 0x97fd885e]
+        );
     }
 
     #[test]
@@ -509,11 +516,22 @@ mod tests {
 
         shuffle(&mut v);
 
-        assert_eq!(v[0].to_vec(), vec![0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc]);
-        assert_eq!(v[1].to_vec(), vec![0x8d07c52d, 0xb9d6aa3a, 0x88609304, 0x408705aa]);
-        assert_eq!(v[2].to_vec(), vec![0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7]);
-        assert_eq!(v[3].to_vec(), vec![0x2cdd25e3, 0x87b6b678, 0x7af31ada, 0x5a2defeb]);
-
+        assert_eq!(
+            v[0].to_vec(),
+            vec![0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc]
+        );
+        assert_eq!(
+            v[1].to_vec(),
+            vec![0x8d07c52d, 0xb9d6aa3a, 0x88609304, 0x408705aa]
+        );
+        assert_eq!(
+            v[2].to_vec(),
+            vec![0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7]
+        );
+        assert_eq!(
+            v[3].to_vec(),
+            vec![0x2cdd25e3, 0x87b6b678, 0x7af31ada, 0x5a2defeb]
+        );
     }
 
     #[test]
@@ -530,9 +548,21 @@ mod tests {
 
         quarter_round(&mut v, rd, rb, m);
 
-        assert_eq!(v[0].to_vec(), vec![0xbc1738c6, 0x566d1711, 0x5bf2cd1d, 0x130c253]);
-        assert_eq!(v[1].to_vec(), vec![0x1ff85cd8, 0x361a0001, 0x6ab383b7, 0xd13ef7a9]);
-        assert_eq!(v[2].to_vec(), vec![0xd4c3d380, 0x3b057bed, 0x27b8af00, 0xb49a500a]);
-        assert_eq!(v[3].to_vec(), vec![0x6ab9ed19, 0x7f9dcd68, 0xeb49bb8e, 0xf4a5ad0]);
+        assert_eq!(
+            v[0].to_vec(),
+            vec![0xbc1738c6, 0x566d1711, 0x5bf2cd1d, 0x130c253]
+        );
+        assert_eq!(
+            v[1].to_vec(),
+            vec![0x1ff85cd8, 0x361a0001, 0x6ab383b7, 0xd13ef7a9]
+        );
+        assert_eq!(
+            v[2].to_vec(),
+            vec![0xd4c3d380, 0x3b057bed, 0x27b8af00, 0xb49a500a]
+        );
+        assert_eq!(
+            v[3].to_vec(),
+            vec![0x6ab9ed19, 0x7f9dcd68, 0xeb49bb8e, 0xf4a5ad0]
+        );
     }
 }
diff --git a/core/src/utils/prove.rs b/core/src/utils/prove.rs
index 84be69a52..1f223cdcf 100644
--- a/core/src/utils/prove.rs
+++ b/core/src/utils/prove.rs
@@ -358,8 +358,8 @@ where
 {
     //#[cfg(debug_assertions)]
     //{
-        let record_clone = record.clone();
-        machine.debug_constraints(pk, record_clone);
+    let record_clone = record.clone();
+    machine.debug_constraints(pk, record_clone);
     //}
     let stats = record.stats().clone();
     let cycles = stats.get("cpu_events").unwrap();

From 04a153a2d9669bfeb5b20daf140ac4ae9b681145 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Wed, 11 Sep 2024 17:20:25 +0300
Subject: [PATCH 05/30] chore: Add computation result writing to the memory

---
 core/src/runtime/syscall.rs                 |  4 +-
 core/src/syscall/precompiles/blake2s/mod.rs | 77 +++++++++++----------
 zkvm/entrypoint/src/syscalls/mod.rs         |  2 +-
 3 files changed, 44 insertions(+), 39 deletions(-)

diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 370b96033..837b90e5a 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -118,7 +118,7 @@ pub enum SyscallCode {
     /// Executes the `HINT_READ` precompile.
     HINT_READ = 0x00_00_00_F1,
 
-    EMPTY = 0x00_00_01_CC,
+    EMPTY = 0x00_01_01_CC,
 }
 
 impl SyscallCode {
@@ -155,7 +155,7 @@ impl SyscallCode {
             0x00_01_01_F2 => SyscallCode::BLS12381_G1_DECOMPRESS,
             0x00_01_01_80 => SyscallCode::BLS12381_G2_ADD,
             0x00_00_01_81 => SyscallCode::BLS12381_G2_DOUBLE,
-            0x00_00_01_CC => SyscallCode::EMPTY,
+            0x00_01_01_CC => SyscallCode::EMPTY,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 7faae1447..75e575a10 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -35,9 +35,8 @@ pub struct EmptyEvent {
     pub channel: u32,
     pub a_ptr: u32,
     pub b_ptr: u32,
-    pub a_reads: Vec<MemoryReadRecord>,
+    pub a_reads_writes: Vec<MemoryWriteRecord>,
     pub b_reads: Vec<MemoryReadRecord>,
-    //pub xor_writes: Vec<MemoryWriteRecord>,
 }
 
 impl Syscall for EmptyChip {
@@ -50,24 +49,24 @@ impl Syscall for EmptyChip {
         let a_ptr = arg1;
         let b_ptr = arg2;
 
-        let mut a_reads = Vec::new();
         let mut b_reads = Vec::new();
 
+        let mut xor = vec![];
         for i in 0..4usize {
             // Read a.
-            let (record, a) = ctx.mr(a_ptr + (i * 4) as u32);
-            a_reads.push(record);
+            let a = ctx.word_unsafe(a_ptr + (i * 4) as u32);
 
             // Read b.
             let (record, b) = ctx.mr(b_ptr + (i * 4) as u32);
             b_reads.push(record);
 
-            let _xor = a ^ b;
+            xor.push(a ^ b);
         }
 
+        ctx.clk += 1;
+
         // Write xor to a_ptr.
-        //xor_writes.push(ctx.mw(a_ptr, xor0));
-        //ctx.clk += 1;
+        let a_reads_writes = ctx.mw_slice(a_ptr, xor.as_slice());
 
         ctx.record_mut().empty_events.push(EmptyEvent {
             lookup_id,
@@ -76,13 +75,16 @@ impl Syscall for EmptyChip {
             channel,
             a_ptr,
             b_ptr,
-            a_reads,
+            a_reads_writes,
             b_reads,
-            //xor_writes: xor0_writes,
         });
 
         None
     }
+
+    fn num_extra_cycles(&self) -> u32 {
+        1
+    }
 }
 
 #[derive(Debug, Clone, AlignedBorrow)]
@@ -97,11 +99,10 @@ struct EmptyCols<T> {
     pub a_ptr: T,
     pub b_ptr: T,
 
-    pub a: [MemoryReadCols<T>; 4],
+    pub a: [MemoryWriteCols<T>; 4],
     pub b: [MemoryReadCols<T>; 4],
 
     pub xor: [XorOperation<T>; 4],
-    //pub axorb: MemoryWriteCols<T>,
 }
 
 impl<T: PrimeField32> BaseAir<T> for EmptyChip {
@@ -143,11 +144,15 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
             cols.b_ptr = F::from_canonical_u32(event.b_ptr);
 
             for i in 0..4usize {
-                cols.a[i].populate(event.channel, event.a_reads[i], &mut new_byte_lookup_events);
+                cols.a[i].populate(
+                    event.channel,
+                    event.a_reads_writes[i],
+                    &mut new_byte_lookup_events,
+                );
 
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
 
-                let a = event.a_reads[i].value;
+                let a = event.a_reads_writes[i].value;
                 let b = event.b_reads[i].value;
                 let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
                 assert_eq!(a ^ b, xor);
@@ -205,17 +210,17 @@ where
             .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
 
         for i in 0..4usize {
-            // Read a.
+            // Eval a
             builder.eval_memory_access(
                 local.shard,
                 local.channel,
-                local.clk,
+                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
                 local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
                 &local.a[i],
                 local.is_real,
             );
 
-            // Read b.
+            // Eval b.
             builder.eval_memory_access(
                 local.shard,
                 local.channel,
@@ -225,7 +230,7 @@ where
                 local.is_real,
             );
 
-            // XOR
+            // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 *local.a[i].value(),
@@ -237,17 +242,6 @@ where
             );
         }
 
-        // Write XOR to memory.
-        //builder.eval_memory_access(
-        //    local.shard,
-        //    local.channel,
-        //    local.clk,
-        //    local.a_ptr,
-        //    &local.a0,
-        //    local.is_real,
-        //);
-        //builder.assert_word_eq(*local.a0.value(), local.xor0.value);
-
         builder.receive_syscall(
             local.shard,
             local.channel,
@@ -264,15 +258,11 @@ where
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::{run_test, setup_logger};
+    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
-    fn risc_v_program(a: [u32; 4], b: [u32; 4]) -> Program {
-        let a_ptr = 100100100;
-        let b_ptr = 200200200;
-
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
         let mut instructions = vec![];
-
         // memory write a
         for (index, word) in a.into_iter().enumerate() {
             instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
@@ -319,11 +309,26 @@ mod tests {
     #[test]
     fn test_empty_precompile() {
         setup_logger();
+
+        let a_ptr = 100100100;
+        let b_ptr = 200200200;
         let program = risc_v_program(
+            a_ptr,
+            b_ptr,
             [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
             [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
         );
-        run_test(program).unwrap();
+        let (_, memory) = run_test_with_memory_inspection(program);
+        let mut result = vec![];
+        // result is 4 words, written to a_ptr
+        for i in 0..4 {
+            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
+        }
+
+        assert_eq!(
+            result,
+            [0x3a06b438, 0x2062c609, 0x23ed2ad9, 0xfeaf3823].to_vec()
+        );
     }
 
     fn xor_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index a7f4993e9..490fd67c7 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -107,4 +107,4 @@ pub const BLS12381_G1_DOUBLE: u32 = 0x00_00_01_72;
 /// Executes `BLS12381_G1_DECOMPRESS`.
 pub const BLS12381_G1_DECOMPRESS: u32 = 0x00_01_01_F2;
 
-pub const EMPTY: u32 = 0x00_00_01_CC;
+pub const EMPTY: u32 = 0x00_01_01_CC;

From e52394d8e615cd8051899bdefb702597d007487c Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Wed, 11 Sep 2024 17:52:10 +0300
Subject: [PATCH 06/30] chore: Inject R_D, R_B constants into memory layout

---
 core/src/syscall/precompiles/blake2s/mod.rs | 64 ++++++++++++++-------
 1 file changed, 44 insertions(+), 20 deletions(-)

diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 75e575a10..a36310266 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -18,6 +18,11 @@ use serde::Serialize;
 use sphinx_derive::AlignedBorrow;
 use std::mem::size_of;
 
+const R_1: u32 = 16;
+const R_2: u32 = 12;
+//const R_3: u32 = 8;
+//const R_4: u32 = 7;
+
 #[derive(Default)]
 pub struct EmptyChip;
 
@@ -49,19 +54,18 @@ impl Syscall for EmptyChip {
         let a_ptr = arg1;
         let b_ptr = arg2;
 
-        let mut b_reads = Vec::new();
+        let a = ctx.slice_unsafe(a_ptr, 4);
+        let (b_reads, mut b) = ctx.mr_slice(b_ptr, 6);
 
-        let mut xor = vec![];
-        for i in 0..4usize {
-            // Read a.
-            let a = ctx.word_unsafe(a_ptr + (i * 4) as u32);
+        let _r_d = b[4].clone();
+        let _r_b = b[5].clone();
+        b.truncate(4);
 
-            // Read b.
-            let (record, b) = ctx.mr(b_ptr + (i * 4) as u32);
-            b_reads.push(record);
-
-            xor.push(a ^ b);
-        }
+        let xor = a
+            .into_iter()
+            .zip(b.into_iter())
+            .map(|(a, b)| a ^ b)
+            .collect::<Vec<u32>>();
 
         ctx.clk += 1;
 
@@ -100,7 +104,7 @@ struct EmptyCols<T> {
     pub b_ptr: T,
 
     pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 4],
+    pub b: [MemoryReadCols<T>; 6], // includes r_d, r_b words
 
     pub xor: [XorOperation<T>; 4],
 }
@@ -158,11 +162,8 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
                 assert_eq!(a ^ b, xor);
             }
 
-            //cols.axorb0.populate(
-            //    event.channel,
-            //    event.xor_writes[0],
-            //    &mut new_byte_lookup_events,
-            //);
+            cols.b[4].populate(event.channel, event.b_reads[4], &mut new_byte_lookup_events); // handle r_d
+            cols.b[5].populate(event.channel, event.b_reads[5], &mut new_byte_lookup_events); // handle r_b
 
             rows.push(row);
         }
@@ -242,6 +243,28 @@ where
             );
         }
 
+        // Eval r_d (included in b_ptr).
+        let i = 4usize;
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+            &local.b[i],
+            local.is_real,
+        );
+
+        // Eval r_d (included in b_ptr).
+        let i = 5usize;
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+            &local.b[i],
+            local.is_real,
+        );
+
         builder.receive_syscall(
             local.shard,
             local.channel,
@@ -258,10 +281,11 @@ where
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
+    use crate::syscall::precompiles::blake2s::{R_1, R_2};
+    use crate::utils::{run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 6]) -> Program {
         let mut instructions = vec![];
         // memory write a
         for (index, word) in a.into_iter().enumerate() {
@@ -316,7 +340,7 @@ mod tests {
             a_ptr,
             b_ptr,
             [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, R_1, R_2],
         );
         let (_, memory) = run_test_with_memory_inspection(program);
         let mut result = vec![];

From 51d5d6e84ff768c3bdcea13f71e022262bcb46a4 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Wed, 11 Sep 2024 20:07:41 +0300
Subject: [PATCH 07/30] chore: Rename Empty to Blake2sXorRotateRight precompile

---
 core/src/runtime/record.rs                  |  40 ++---
 core/src/runtime/syscall.rs                 |  18 ++-
 core/src/stark/air.rs                       |   8 +-
 core/src/syscall/precompiles/blake2s/mod.rs | 159 +++++++++++---------
 zkvm/entrypoint/src/syscalls/mod.rs         |   2 +-
 5 files changed, 127 insertions(+), 100 deletions(-)

diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index 28acd247b..50ace6dd2 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -10,7 +10,7 @@ use super::{program::Program, Opcode};
 use crate::runtime::MemoryInitializeFinalizeEvent;
 use crate::runtime::MemoryRecordEnum;
 use crate::stark::MachineRecord;
-use crate::syscall::precompiles::blake2s::{EmptyChip, EmptyEvent};
+use crate::syscall::precompiles::blake2s::{Blake2sXorRotateRightChip, Blake2sXorRotateRightEvent};
 use crate::syscall::precompiles::edwards::EdDecompressEvent;
 use crate::syscall::precompiles::keccak256::KeccakPermuteEvent;
 use crate::syscall::precompiles::sha256::{ShaCompressEvent, ShaExtendEvent};
@@ -97,8 +97,6 @@ pub struct ExecutionRecord {
 
     pub sha_extend_events: Vec<ShaExtendEvent>,
 
-    pub empty_events: Vec<EmptyEvent>,
-
     pub sha_compress_events: Vec<ShaCompressEvent>,
 
     pub keccak_permute_events: Vec<KeccakPermuteEvent>,
@@ -128,6 +126,8 @@ pub struct ExecutionRecord {
     pub bls12381_g2_add_events: Vec<Bls12381G2AffineAddEvent>,
     pub bls12381_g2_double_events: Vec<Bls12381G2AffineDoubleEvent>,
 
+    pub blake2s_xor_rotate_right_events: Vec<Blake2sXorRotateRightEvent>,
+
     pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
 
     pub memory_finalize_events: Vec<MemoryInitializeFinalizeEvent>,
@@ -217,12 +217,6 @@ impl EventLens<ShaExtendChip> for ExecutionRecord {
     }
 }
 
-impl EventLens<EmptyChip> for ExecutionRecord {
-    fn events(&self) -> <EmptyChip as crate::air::WithEvents<'_>>::Events {
-        &self.empty_events
-    }
-}
-
 impl EventLens<ShaCompressChip> for ExecutionRecord {
     fn events(&self) -> <ShaCompressChip as crate::air::WithEvents<'_>>::Events {
         &self.sha_compress_events
@@ -327,6 +321,12 @@ impl EventLens<EdDecompressChip<Ed25519Parameters>> for ExecutionRecord {
     }
 }
 
+impl EventLens<Blake2sXorRotateRightChip> for ExecutionRecord {
+    fn events(&self) -> <Blake2sXorRotateRightChip as crate::air::WithEvents<'_>>::Events {
+        &self.blake2s_xor_rotate_right_events
+    }
+}
+
 pub struct ShardingConfig {
     pub shard_size: usize,
     pub add_len: usize,
@@ -420,7 +420,6 @@ impl MachineRecord for ExecutionRecord {
             "sha_compress_events".to_string(),
             self.sha_compress_events.len(),
         );
-        stats.insert("empty_events".to_string(), self.empty_events.len());
         stats.insert(
             "keccak_permute_events".to_string(),
             self.keccak_permute_events.len(),
@@ -475,6 +474,10 @@ impl MachineRecord for ExecutionRecord {
             "bls12381_g2_double_events".to_string(),
             self.bls12381_g2_double_events.len(),
         );
+        stats.insert(
+            "blake2s_xor_rotate_right_events".to_string(),
+            self.blake2s_xor_rotate_right_events.len(),
+        );
         stats
     }
 
@@ -492,9 +495,6 @@ impl MachineRecord for ExecutionRecord {
         self.sha_extend_events.append(&mut other.sha_extend_events);
         self.sha_compress_events
             .append(&mut other.sha_compress_events);
-
-        self.empty_events.append(&mut other.empty_events);
-
         self.keccak_permute_events
             .append(&mut other.keccak_permute_events);
         self.ed_add_events.append(&mut other.ed_add_events);
@@ -523,6 +523,8 @@ impl MachineRecord for ExecutionRecord {
             .append(&mut other.bls12381_g2_add_events);
         self.bls12381_g2_double_events
             .append(&mut other.bls12381_g2_double_events);
+        self.blake2s_xor_rotate_right_events
+            .append(&mut other.blake2s_xor_rotate_right_events);
 
         // Merge the byte lookups.
         for (shard, events_map) in take(&mut other.byte_lookups) {
@@ -808,12 +810,6 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, (i * 48) as u32);
         }
 
-        // Empty events
-        first.empty_events = take(&mut self.empty_events);
-        for (i, event) in first.empty_events.iter().enumerate() {
-            self.nonce_lookup.insert(event.lookup_id, i as u32);
-        }
-
         // SHA-256 compress events.
         first.sha_compress_events = take(&mut self.sha_compress_events);
         for (i, event) in first.sha_compress_events.iter().enumerate() {
@@ -856,6 +852,12 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
+        // blake2s_xor_rotate_right events
+        first.blake2s_xor_rotate_right_events = take(&mut self.blake2s_xor_rotate_right_events);
+        for (i, event) in first.blake2s_xor_rotate_right_events.iter().enumerate() {
+            self.nonce_lookup.insert(event.lookup_id, i as u32);
+        }
+
         // Put MemoryInit / MemoryFinalize events in the last shard.
         let last = shards.last_mut().unwrap();
         last.memory_initialize_events
diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 837b90e5a..2f2372564 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -6,7 +6,7 @@ use strum_macros::EnumIter;
 
 use crate::runtime::{Register, Runtime};
 use crate::stark::Ed25519Parameters;
-use crate::syscall::precompiles::blake2s::EmptyChip;
+use crate::syscall::precompiles::blake2s::Blake2sXorRotateRightChip;
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::bls12_381::g2_add::Bls12381G2AffineAddChip;
 use crate::syscall::precompiles::bls12_381::g2_double::Bls12381G2AffineDoubleChip;
@@ -118,7 +118,7 @@ pub enum SyscallCode {
     /// Executes the `HINT_READ` precompile.
     HINT_READ = 0x00_00_00_F1,
 
-    EMPTY = 0x00_01_01_CC,
+    BLAKE_2S_XOR_ROTATE_RIGHT = 0x00_01_01_CC,
 }
 
 impl SyscallCode {
@@ -155,7 +155,7 @@ impl SyscallCode {
             0x00_01_01_F2 => SyscallCode::BLS12381_G1_DECOMPRESS,
             0x00_01_01_80 => SyscallCode::BLS12381_G2_ADD,
             0x00_00_01_81 => SyscallCode::BLS12381_G2_DOUBLE,
-            0x00_01_01_CC => SyscallCode::EMPTY,
+            0x00_01_01_CC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -394,7 +394,10 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
         Arc::new(Bls12381G2AffineDoubleChip::new()),
     );
 
-    syscall_map.insert(SyscallCode::EMPTY, Arc::new(EmptyChip::new()));
+    syscall_map.insert(
+        SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT,
+        Arc::new(Blake2sXorRotateRightChip::new()),
+    );
 
     syscall_map
 }
@@ -510,8 +513,11 @@ mod tests {
                     assert_eq!(code as u32, sphinx_zkvm::syscalls::BLS12381_G2_DOUBLE)
                 }
 
-                SyscallCode::EMPTY => {
-                    assert_eq!(code as u32, sphinx_zkvm::syscalls::EMPTY)
+                SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT => {
+                    assert_eq!(
+                        code as u32,
+                        sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT
+                    )
                 }
             }
         }
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index 5cdeec2e3..835709f3f 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -3,7 +3,7 @@ pub use crate::air::SphinxAirBuilder;
 use crate::air::{MachineAir, SPHINX_PROOF_NUM_PV_ELTS};
 use crate::memory::{MemoryChipType, MemoryProgramChip};
 use crate::stark::Chip;
-use crate::syscall::precompiles::blake2s::EmptyChip;
+use crate::syscall::precompiles::blake2s::Blake2sXorRotateRightChip;
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::field::FieldChip;
 use crate::syscall::precompiles::quad_field::QuadFieldChip;
@@ -108,7 +108,7 @@ pub enum RiscvAir<F: PrimeField32> {
     /// A precompile for decompressing a point on the BLS12-381 curve.
     Bls12381G1Decompress(Bls12381G1DecompressChip),
 
-    Empty(EmptyChip),
+    Blake2sXorRotateRight(Blake2sXorRotateRightChip),
 }
 
 impl<F: PrimeField32> RiscvAir<F> {
@@ -185,8 +185,8 @@ impl<F: PrimeField32> RiscvAir<F> {
         let byte = ByteChip::default();
         chips.push(RiscvAir::ByteLookup(byte));
 
-        let empty = EmptyChip::default();
-        chips.push(RiscvAir::Empty(empty));
+        let blake_2s_xor_rotate_right = Blake2sXorRotateRightChip::default();
+        chips.push(RiscvAir::Blake2sXorRotateRight(blake_2s_xor_rotate_right));
 
         chips
     }
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index a36310266..66e66d740 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -1,6 +1,6 @@
 use crate::bytes::event::ByteRecord;
 use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::XorOperation;
+use crate::operations::{FixedRotateRightOperation, XorOperation};
 use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
 use crate::stark::SphinxAirBuilder;
 use crate::utils::pad_rows;
@@ -19,32 +19,33 @@ use sphinx_derive::AlignedBorrow;
 use std::mem::size_of;
 
 const R_1: u32 = 16;
-const R_2: u32 = 12;
+//const R_2: u32 = 12;
 //const R_3: u32 = 8;
 //const R_4: u32 = 7;
 
 #[derive(Default)]
-pub struct EmptyChip;
+pub struct Blake2sXorRotateRightChip;
 
-impl EmptyChip {
+impl Blake2sXorRotateRightChip {
     pub fn new() -> Self {
-        EmptyChip
+        Blake2sXorRotateRightChip
     }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct EmptyEvent {
+pub struct Blake2sXorRotateRightEvent {
     pub lookup_id: usize,
     pub clk: u32,
     pub shard: u32,
     pub channel: u32,
     pub a_ptr: u32,
     pub b_ptr: u32,
+    pub rot: u32,
     pub a_reads_writes: Vec<MemoryWriteRecord>,
     pub b_reads: Vec<MemoryReadRecord>,
 }
 
-impl Syscall for EmptyChip {
+impl Syscall for Blake2sXorRotateRightChip {
     fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
         let clk_init = ctx.clk;
         let shard = ctx.current_shard();
@@ -55,10 +56,9 @@ impl Syscall for EmptyChip {
         let b_ptr = arg2;
 
         let a = ctx.slice_unsafe(a_ptr, 4);
-        let (b_reads, mut b) = ctx.mr_slice(b_ptr, 6);
+        let (b_reads, mut b) = ctx.mr_slice(b_ptr, 5);
 
-        let _r_d = b[4].clone();
-        let _r_b = b[5].clone();
+        let rot = b[4].clone();
         b.truncate(4);
 
         let xor = a
@@ -67,21 +67,29 @@ impl Syscall for EmptyChip {
             .map(|(a, b)| a ^ b)
             .collect::<Vec<u32>>();
 
-        ctx.clk += 1;
+        let rotate_right = xor
+            .into_iter()
+            .map(|xor_i| xor_i.rotate_right(rot))
+            .collect::<Vec<u32>>();
 
-        // Write xor to a_ptr.
-        let a_reads_writes = ctx.mw_slice(a_ptr, xor.as_slice());
+        ctx.clk += 1;
 
-        ctx.record_mut().empty_events.push(EmptyEvent {
-            lookup_id,
-            clk: clk_init,
-            shard,
-            channel,
-            a_ptr,
-            b_ptr,
-            a_reads_writes,
-            b_reads,
-        });
+        // Write rotate_right to a_ptr.
+        let a_reads_writes = ctx.mw_slice(a_ptr, rotate_right.as_slice());
+
+        ctx.record_mut()
+            .blake2s_xor_rotate_right_events
+            .push(Blake2sXorRotateRightEvent {
+                lookup_id,
+                clk: clk_init,
+                shard,
+                channel,
+                a_ptr,
+                b_ptr,
+                rot,
+                a_reads_writes,
+                b_reads,
+            });
 
         None
     }
@@ -93,7 +101,7 @@ impl Syscall for EmptyChip {
 
 #[derive(Debug, Clone, AlignedBorrow)]
 #[repr(C)]
-struct EmptyCols<T> {
+struct Blake2sXorRotateRightCols<T> {
     pub clk: T,
     pub shard: T,
     pub channel: T,
@@ -104,27 +112,28 @@ struct EmptyCols<T> {
     pub b_ptr: T,
 
     pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 6], // includes r_d, r_b words
+    pub b: [MemoryReadCols<T>; 5], // includes rotation constant
 
     pub xor: [XorOperation<T>; 4],
+    pub rotate_right: [FixedRotateRightOperation<T>; 4],
 }
 
-impl<T: PrimeField32> BaseAir<T> for EmptyChip {
+impl<T: PrimeField32> BaseAir<T> for Blake2sXorRotateRightChip {
     fn width(&self) -> usize {
-        size_of::<EmptyCols<u8>>()
+        size_of::<Blake2sXorRotateRightCols<u8>>()
     }
 }
 
-impl<'a> WithEvents<'a> for EmptyChip {
-    type Events = &'a [EmptyEvent];
+impl<'a> WithEvents<'a> for Blake2sXorRotateRightChip {
+    type Events = &'a [Blake2sXorRotateRightEvent];
 }
 
-impl<F: PrimeField32> MachineAir<F> for EmptyChip {
+impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRightChip {
     type Record = ExecutionRecord;
     type Program = Program;
 
     fn name(&self) -> String {
-        "EmptyChip".to_string()
+        "Blake2sXorRotateRightChip".to_string()
     }
 
     fn generate_trace<EL: EventLens<Self>>(
@@ -133,12 +142,12 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
         output: &mut Self::Record,
     ) -> RowMajorMatrix<F> {
         let mut rows = vec![];
-        let width = <EmptyChip as BaseAir<F>>::width(self);
+        let width = <Blake2sXorRotateRightChip as BaseAir<F>>::width(self);
         let mut new_byte_lookup_events = Vec::new();
         for event in input.events() {
             let shard = event.shard;
             let mut row = vec![F::zero(); width];
-            let cols: &mut EmptyCols<F> = row.as_mut_slice().borrow_mut();
+            let cols: &mut Blake2sXorRotateRightCols<F> = row.as_mut_slice().borrow_mut();
 
             cols.clk = F::from_canonical_u32(event.clk);
             cols.is_real = F::one();
@@ -147,6 +156,10 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
             cols.a_ptr = F::from_canonical_u32(event.a_ptr);
             cols.b_ptr = F::from_canonical_u32(event.b_ptr);
 
+            cols.b[4].populate(event.channel, event.b_reads[4], &mut new_byte_lookup_events); // handle rotation_constant
+
+            let rot = event.b_reads[4].value;
+
             for i in 0..4usize {
                 cols.a[i].populate(
                     event.channel,
@@ -160,10 +173,11 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
                 let b = event.b_reads[i].value;
                 let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
                 assert_eq!(a ^ b, xor);
-            }
 
-            cols.b[4].populate(event.channel, event.b_reads[4], &mut new_byte_lookup_events); // handle r_d
-            cols.b[5].populate(event.channel, event.b_reads[5], &mut new_byte_lookup_events); // handle r_b
+                let rotate_right =
+                    cols.rotate_right[i].populate(output, shard, event.channel, xor, rot as usize);
+                assert_eq!(xor.rotate_right(rot), rotate_right);
+            }
 
             rows.push(row);
         }
@@ -181,7 +195,8 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
 
         // Write the nonces to the trace.
         for i in 0..trace.height() {
-            let cols: &mut EmptyCols<F> = trace.values[i * width..(i + 1) * width].borrow_mut();
+            let cols: &mut Blake2sXorRotateRightCols<F> =
+                trace.values[i * width..(i + 1) * width].borrow_mut();
             cols.nonce = F::from_canonical_usize(i);
         }
 
@@ -189,11 +204,11 @@ impl<F: PrimeField32> MachineAir<F> for EmptyChip {
     }
 
     fn included(&self, shard: &Self::Record) -> bool {
-        !shard.empty_events.is_empty()
+        !shard.blake2s_xor_rotate_right_events.is_empty()
     }
 }
 
-impl<AB: SphinxAirBuilder> Air<AB> for EmptyChip
+impl<AB: SphinxAirBuilder> Air<AB> for Blake2sXorRotateRightChip
 where
     AB::F: PrimeField32,
 {
@@ -201,8 +216,8 @@ where
         let main = builder.main();
         let local = main.row_slice(0);
         let next = main.row_slice(1);
-        let local: &EmptyCols<AB::Var> = (*local).borrow();
-        let next: &EmptyCols<AB::Var> = (*next).borrow();
+        let local: &Blake2sXorRotateRightCols<AB::Var> = (*local).borrow();
+        let next: &Blake2sXorRotateRightCols<AB::Var> = (*next).borrow();
 
         // Constrain the incrementing nonce.
         builder.when_first_row().assert_zero(local.nonce);
@@ -210,6 +225,20 @@ where
             .when_transition()
             .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
 
+        // Eval rotation_constant (included as 4th word in b_ptr).
+        let i = 4usize;
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+            &local.b[i],
+            local.is_real,
+        );
+
+        // TODO: get rotation constant from memory somehow
+        let _rot = *local.b[4].value();
+
         for i in 0..4usize {
             // Eval a
             builder.eval_memory_access(
@@ -241,36 +270,25 @@ where
                 &local.channel,
                 local.is_real,
             );
-        }
-
-        // Eval r_d (included in b_ptr).
-        let i = 4usize;
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-            &local.b[i],
-            local.is_real,
-        );
 
-        // Eval r_d (included in b_ptr).
-        let i = 5usize;
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-            &local.b[i],
-            local.is_real,
-        );
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i].value,
+                R_1 as usize, // TODO use value from memory instead !
+                local.rotate_right[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+        }
 
         builder.receive_syscall(
             local.shard,
             local.channel,
             local.clk,
             local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::EMPTY.syscall_id()),
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT.syscall_id()),
             local.a_ptr,
             local.b_ptr,
             local.is_real,
@@ -281,11 +299,11 @@ where
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::syscall::precompiles::blake2s::{R_1, R_2};
+    use crate::syscall::precompiles::blake2s::R_1;
     use crate::utils::{run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 6]) -> Program {
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 5]) -> Program {
         let mut instructions = vec![];
         // memory write a
         for (index, word) in a.into_iter().enumerate() {
@@ -320,7 +338,7 @@ mod tests {
             Opcode::ADD,
             5,
             0,
-            SyscallCode::EMPTY as u32,
+            SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT as u32,
             false,
             true,
         ));
@@ -331,7 +349,7 @@ mod tests {
     }
 
     #[test]
-    fn test_empty_precompile() {
+    fn test_blake2s_xor_rotate_right_precompile() {
         setup_logger();
 
         let a_ptr = 100100100;
@@ -340,8 +358,9 @@ mod tests {
             a_ptr,
             b_ptr,
             [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, R_1, R_2],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, R_1],
         );
+
         let (_, memory) = run_test_with_memory_inspection(program);
         let mut result = vec![];
         // result is 4 words, written to a_ptr
@@ -351,7 +370,7 @@ mod tests {
 
         assert_eq!(
             result,
-            [0x3a06b438, 0x2062c609, 0x23ed2ad9, 0xfeaf3823].to_vec()
+            [0xb4383a06, 0xc6092062, 0x2ad923ed, 0x3823feaf].to_vec()
         );
     }
 
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 490fd67c7..ec16b486e 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -107,4 +107,4 @@ pub const BLS12381_G1_DOUBLE: u32 = 0x00_00_01_72;
 /// Executes `BLS12381_G1_DECOMPRESS`.
 pub const BLS12381_G1_DECOMPRESS: u32 = 0x00_01_01_F2;
 
-pub const EMPTY: u32 = 0x00_01_01_CC;
+pub const BLAKE_2S_XOR_ROTATE_RIGHT: u32 = 0x00_01_01_CC;

From b1831c6f9780c0ec7ac2d6b47042af7372d7b059 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Wed, 11 Sep 2024 21:01:35 +0300
Subject: [PATCH 08/30] chore: Add integration test for
 BLAKE2S_XOR_ROTATE_RIGHT precompile

---
 core/src/syscall/precompiles/blake2s/mod.rs   |  18 +-
 core/src/utils/programs.rs                    |   3 +
 tests/blake2s-xor-rotate-right/Cargo.lock     | 539 ++++++++++++++++++
 tests/blake2s-xor-rotate-right/Cargo.toml     |   8 +
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 0 -> 25148 bytes
 tests/blake2s-xor-rotate-right/src/main.rs    |  31 +
 .../src/syscalls/blake2s_xor_rotate_right.rs  |  19 +
 zkvm/entrypoint/src/syscalls/mod.rs           |   2 +
 zkvm/precompiles/src/lib.rs                   |   1 +
 9 files changed, 616 insertions(+), 5 deletions(-)
 create mode 100644 tests/blake2s-xor-rotate-right/Cargo.lock
 create mode 100644 tests/blake2s-xor-rotate-right/Cargo.toml
 create mode 100755 tests/blake2s-xor-rotate-right/elf/riscv32im-succinct-zkvm-elf
 create mode 100644 tests/blake2s-xor-rotate-right/src/main.rs
 create mode 100644 zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right.rs

diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 66e66d740..beac20a1c 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -172,11 +172,11 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRightChip {
                 let a = event.a_reads_writes[i].value;
                 let b = event.b_reads[i].value;
                 let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
-                assert_eq!(a ^ b, xor);
+                //assert_eq!(a ^ b, xor);
 
-                let rotate_right =
+                let _rotate_right =
                     cols.rotate_right[i].populate(output, shard, event.channel, xor, rot as usize);
-                assert_eq!(xor.rotate_right(rot), rotate_right);
+                //assert_eq!(xor.rotate_right(rot), rotate_right);
             }
 
             rows.push(row);
@@ -237,7 +237,7 @@ where
         );
 
         // TODO: get rotation constant from memory somehow
-        let _rot = *local.b[4].value();
+        //let _rot = *local.b[4].value();
 
         for i in 0..4usize {
             // Eval a
@@ -300,7 +300,8 @@ where
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
     use crate::syscall::precompiles::blake2s::R_1;
-    use crate::utils::{run_test_with_memory_inspection, setup_logger};
+    use crate::utils::tests::BLAKE2S_XOR_RIGHT_ROTATE_ELF;
+    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
     fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 5]) -> Program {
@@ -374,6 +375,13 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_blake2s_xor_right_rotate_program() {
+        setup_logger();
+        let program = Program::from(BLAKE2S_XOR_RIGHT_ROTATE_ELF);
+        run_test(program).unwrap();
+    }
+
     fn xor_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
         [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]]
     }
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index 132f6c5cf..bbaf1f342 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -121,6 +121,9 @@ pub mod tests {
     pub const BLS12381_G2_DOUBLE_ELF: &[u8] =
         include_bytes!("../../../tests/bls12381-g2-double/elf/riscv32im-succinct-zkvm-elf");
 
+    pub const BLAKE2S_XOR_RIGHT_ROTATE_ELF: &[u8] =
+        include_bytes!("../../../tests/blake2s-xor-rotate-right/elf/riscv32im-succinct-zkvm-elf");
+
     pub const PANIC_ELF: &[u8] =
         include_bytes!("../../../tests/panic/elf/riscv32im-succinct-zkvm-elf");
 }
diff --git a/tests/blake2s-xor-rotate-right/Cargo.lock b/tests/blake2s-xor-rotate-right/Cargo.lock
new file mode 100644
index 000000000..733b51ebb
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right/Cargo.lock
@@ -0,0 +1,539 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10f00e1f6e58a40e807377c75c6a7f97bf9044fab57816f2414e6f5f4499d7b8"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2s-xor-rotate-right-test"
+version = "0.1.0"
+dependencies = [
+ "sphinx-zkvm",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest",
+ "elliptic-curve",
+ "rfc6979",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest",
+ "ff",
+ "generic-array",
+ "group",
+ "pkcs8",
+ "rand_core",
+ "sec1",
+ "subtle",
+ "tap",
+ "zeroize",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "bitvec",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.2.0-rc.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "once_cell",
+ "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "signature",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "sphinx-precompiles"
+version = "1.0.0"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "hybrid-array",
+ "k256",
+ "serde",
+]
+
+[[package]]
+name = "sphinx-zkvm"
+version = "1.0.0"
+dependencies = [
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "k256",
+ "lazy_static",
+ "libm",
+ "once_cell",
+ "rand",
+ "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
+ "sphinx-precompiles",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-xor-rotate-right/Cargo.toml b/tests/blake2s-xor-rotate-right/Cargo.toml
new file mode 100644
index 000000000..8d49fdcb8
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right/Cargo.toml
@@ -0,0 +1,8 @@
+[workspace]
+[package]
+name = "blake2s-xor-rotate-right-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-xor-rotate-right/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-right/elf/riscv32im-succinct-zkvm-elf
new file mode 100755
index 0000000000000000000000000000000000000000..77111e1412cde84eb8a5897002ba4d0f055cfc2d
GIT binary patch
literal 25148
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
YF4duHDQ?2eyZ&?y{0Z*^Pp{tp1JB<Io&W#<

literal 0
HcmV?d00001

diff --git a/tests/blake2s-xor-rotate-right/src/main.rs b/tests/blake2s-xor-rotate-right/src/main.rs
new file mode 100644
index 000000000..189fad18e
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right/src/main.rs
@@ -0,0 +1,31 @@
+#![no_main]
+sphinx_zkvm::entrypoint!(main);
+
+use sphinx_zkvm::syscalls::blake2s_xor_rotate_right::syscall_blake2s_xor_rotate_right;
+
+const R_1: u32 = 16;
+
+pub fn main() {
+    let mut a: [u32; 4] = [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
+    let b: [u32; 5] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, R_1];
+
+    syscall_blake2s_xor_rotate_right(a.as_mut_ptr(), b.as_ptr());
+
+    assert_eq!(a, [0xb4383a06, 0xc6092062, 0x2ad923ed, 0x3823feaf]);
+
+    // precompile code
+    //for _ in 0..10000 {
+    //    syscall_blake2s_xor_rotate_right(a.as_mut_ptr(), b.as_ptr());
+    //}
+
+    // no-precompile code
+    //for _ in 0..10000 {
+    //    for i in 0..4usize {
+    //        a[i] = (a[i] ^ b[i]).rotate_right(b[4]);
+    //    }
+    //}
+}
+
+
+// summary: cycles=61049, e2e=3532, khz=17.28, proofSize=1.84 MiB (precompile)
+// summary: cycles=1044, e2e=1691, khz=0.62, proofSize=1.84 MiB (no precompile)
\ No newline at end of file
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right.rs
new file mode 100644
index 000000000..0c912e620
--- /dev/null
+++ b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right.rs
@@ -0,0 +1,19 @@
+#[cfg(target_os = "zkvm")]
+use core::arch::asm;
+
+#[allow(unused_variables)]
+#[no_mangle]
+pub extern "C" fn syscall_blake2s_xor_rotate_right(left: *mut u32, right: *const u32) {
+    #[cfg(target_os = "zkvm")]
+    unsafe {
+        asm!(
+        "ecall",
+        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT,
+        in("a0") left,
+        in("a1") right
+        );
+    }
+
+    #[cfg(not(target_os = "zkvm"))]
+    unreachable!()
+}
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index ec16b486e..6d02fcc35 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -13,6 +13,8 @@ mod unconstrained;
 #[cfg(feature = "verify")]
 mod verify;
 
+pub mod blake2s_xor_rotate_right;
+
 pub use bls12_381::*;
 pub use bn254::*;
 pub use ed25519::*;
diff --git a/zkvm/precompiles/src/lib.rs b/zkvm/precompiles/src/lib.rs
index 4dd6257e4..3619e4711 100644
--- a/zkvm/precompiles/src/lib.rs
+++ b/zkvm/precompiles/src/lib.rs
@@ -47,4 +47,5 @@ extern "C" {
     pub fn sys_alloc_aligned(bytes: usize, align: usize) -> *mut u8;
     pub fn syscall_bls12381_g2_add(p: *mut u32, q: *const u32);
     pub fn syscall_bls12381_g2_double(p: *mut u32);
+    pub fn syscall_blake2s_xor_rotate_right(left: *mut u32, right: *const u32);
 }

From 121b819c55b55c39b8230a5f091d3b1c94e8adfb Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Fri, 13 Sep 2024 20:03:30 +0300
Subject: [PATCH 09/30] feat: More optimal Blake2s XOR right-rotate syscall

---
 Cargo.lock                                    | 740 ++++++++++--------
 core/src/runtime/record.rs                    |  25 +-
 core/src/runtime/syscall.rs                   |  14 +-
 core/src/stark/air.rs                         |   6 +-
 core/src/syscall/precompiles/blake2s/mod.rs   |  48 +-
 .../precompiles/blake2s/xor_rotate_16/air.rs  | 291 +++++++
 .../blake2s/xor_rotate_16/columns.rs          |  71 ++
 .../blake2s/xor_rotate_16/execute.rs          | 101 +++
 .../blake2s/xor_rotate_16/flags.rs            | 130 +++
 .../precompiles/blake2s/xor_rotate_16/mod.rs  | 116 +++
 .../blake2s/xor_rotate_16/trace.rs            | 178 +++++
 core/src/utils/programs.rs                    |   3 +
 tests/blake2s-xor-rotate-16/Cargo.lock        | 539 +++++++++++++
 tests/blake2s-xor-rotate-16/Cargo.toml        |   8 +
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 0 -> 22924 bytes
 tests/blake2s-xor-rotate-16/src/main.rs       |  13 +
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25148 -> 25140 bytes
 tests/blake2s-xor-rotate-right/src/main.rs    |   4 +-
 .../src/syscalls/blake2s_xor_rotate_16.rs     |  19 +
 zkvm/entrypoint/src/syscalls/mod.rs           |   3 +
 zkvm/precompiles/src/lib.rs                   |   1 +
 21 files changed, 1923 insertions(+), 387 deletions(-)
 create mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/air.rs
 create mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/columns.rs
 create mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/execute.rs
 create mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/flags.rs
 create mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/mod.rs
 create mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/trace.rs
 create mode 100644 tests/blake2s-xor-rotate-16/Cargo.lock
 create mode 100644 tests/blake2s-xor-rotate-16/Cargo.toml
 create mode 100755 tests/blake2s-xor-rotate-16/elf/riscv32im-succinct-zkvm-elf
 create mode 100644 tests/blake2s-xor-rotate-16/src/main.rs
 create mode 100644 zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_16.rs

diff --git a/Cargo.lock b/Cargo.lock
index 6bc253a64..48201fb87 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -25,18 +25,18 @@ dependencies = [
 
 [[package]]
 name = "addr2line"
-version = "0.22.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
+checksum = "f5fb1d8e4442bd405fdfd1dacb42792696b0cf9cb15882e5d097b742a676d375"
 dependencies = [
  "gimli",
 ]
 
 [[package]]
-name = "adler"
-version = "1.0.2"
+name = "adler2"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
 
 [[package]]
 name = "aes"
@@ -100,9 +100,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-rlp"
-version = "0.3.5"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b155716bab55763c95ba212806cf43d05bcc70e5f35b02bad20cf5ec7fe11fed"
+checksum = "26154390b1d205a4a7ac7352aa2eb4f81f391399d4e2f546fb81a2f8bb383f62"
 dependencies = [
  "arrayvec",
  "bytes",
@@ -119,7 +119,7 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -131,11 +131,11 @@ dependencies = [
  "alloy-sol-macro-input",
  "const-hex",
  "heck",
- "indexmap 2.2.6",
+ "indexmap 2.5.0",
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
  "syn-solidity",
  "tiny-keccak",
 ]
@@ -151,7 +151,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
  "syn-solidity",
 ]
 
@@ -199,9 +199,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.6.14"
+version = "0.6.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b"
+checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -220,27 +220,27 @@ checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
+checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391"
+checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a"
 dependencies = [
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.3"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19"
+checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8"
 dependencies = [
  "anstyle",
  "windows-sys 0.52.0",
@@ -248,9 +248,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.86"
+version = "1.0.88"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+checksum = "4e1496f8fb1fbf272686b8d37f523dab3e4a7443300055e74cdaa449f3114356"
 dependencies = [
  "backtrace",
 ]
@@ -289,7 +289,7 @@ dependencies = [
  "num-bigint 0.4.6",
  "num-traits",
  "paste",
- "rustc_version 0.4.0",
+ "rustc_version 0.4.1",
  "zeroize",
 ]
 
@@ -387,19 +387,19 @@ checksum = "9d151e35f61089500b617991b791fc8bfd237ae50cd5950803758a179b41e67a"
 
 [[package]]
 name = "arrayvec"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "async-trait"
-version = "0.1.81"
+version = "0.1.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e0c28dcc82d7c8ead5cb13beb15405b57b8546e93215673ff8ca0349a028107"
+checksum = "a27b8a3a6e1a44fa4c8baf1f653e4172e81486d4941f2237e20dc2d0cf4ddff1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -410,7 +410,7 @@ checksum = "b6d7b9decdf35d8908a7e3ef02f64c5e9b1695e230154c0e8de3969142d9b94c"
 dependencies = [
  "futures",
  "pharos",
- "rustc_version 0.4.0",
+ "rustc_version 0.4.1",
 ]
 
 [[package]]
@@ -421,7 +421,7 @@ checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -441,9 +441,9 @@ dependencies = [
  "bytes",
  "futures-util",
  "http 1.1.0",
- "http-body 1.0.0",
+ "http-body 1.0.1",
  "http-body-util",
- "hyper 1.3.1",
+ "hyper 1.4.1",
  "hyper-util",
  "itoa",
  "matchit",
@@ -474,7 +474,7 @@ dependencies = [
  "bytes",
  "futures-util",
  "http 1.1.0",
- "http-body 1.0.0",
+ "http-body 1.0.1",
  "http-body-util",
  "mime",
  "pin-project-lite",
@@ -487,18 +487,18 @@ dependencies = [
 
 [[package]]
 name = "backtrace"
-version = "0.3.73"
+version = "0.3.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
+checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
 dependencies = [
  "addr2line",
- "cc",
  "cfg-if",
  "libc",
  "miniz_oxide",
  "object",
  "rustc-demangle",
  "serde",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -552,10 +552,10 @@ version = "0.69.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "cexpr",
  "clang-sys",
- "itertools 0.10.5",
+ "itertools 0.12.1",
  "lazy_static",
  "lazycell",
  "log",
@@ -563,9 +563,9 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "shlex",
- "syn 2.0.68",
+ "syn 2.0.77",
  "which",
 ]
 
@@ -592,9 +592,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "bitvec"
@@ -630,9 +630,9 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.5.3"
+version = "1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9ec96fe9a81b5e365f9db71fe00edc4fe4ca2cc7dcb7861f0603012a7caa210"
+checksum = "d82033247fd8e890df8f740e407ad4d038debb9eb1f40533fffb32e7d17dc6f7"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -667,13 +667,14 @@ dependencies = [
 [[package]]
 name = "bls12_381"
 version = "0.8.0"
-source = "git+https://github.com/argumentcomputer/bls12_381.git?branch=zkvm#0d57d6ac0af6a464c4764809b5bf994d15920762"
+source = "git+https://github.com/argumentcomputer/bls12_381.git?branch=zkvm#2a96eccde19bf861b0d1707b61b2ab15e294b154"
 dependencies = [
  "cfg-if",
  "ff 0.13.0",
  "group 0.13.0",
  "pairing 0.23.0",
  "rand_core",
+ "sphinx-precompiles 1.0.0 (git+https://github.com/argumentcomputer/sphinx?branch=dev)",
  "subtle",
 ]
 
@@ -701,9 +702,9 @@ checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
 
 [[package]]
 name = "bytemuck"
-version = "1.16.3"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "102087e286b4677862ea56cf8fc58bb2cdfa8725c40ffb80fe3a008eb7f2fc83"
+checksum = "94bbb0ad554ad961ddc5da507a12a29b14e4ae5bda06b19f575a3e6079d2e2ae"
 
 [[package]]
 name = "byteorder"
@@ -713,18 +714,18 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.6.0"
+version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
+checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "camino"
-version = "1.1.7"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0ec6b951b160caa93cc0c7b209e5a3bff7aae9062213451ac99493cd844c239"
+checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
 dependencies = [
  "serde",
 ]
@@ -760,12 +761,13 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.1.10"
+version = "1.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9e8aabfac534be767c909e0690571677d49f41bd8465ae876fe043d52ba5292"
+checksum = "b62ac837cdb5cb22e10a256099b4fc502b1dfe560cb282963a974d7abd80e476"
 dependencies = [
  "jobserver",
  "libc",
+ "shlex",
 ]
 
 [[package]]
@@ -846,9 +848,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.15"
+version = "4.5.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11d8838454fda655dafd3accb2b6e2bea645b9e4078abe84a22ceb947235c5cc"
+checksum = "3e5a21b8495e732f1b3c364c9949b201ca7bae518c502c80256c96ad79eaf6ac"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -856,9 +858,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.15"
+version = "4.5.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "216aec2b177652e3846684cbfe25c9964d18ec45234f0f5da5157b207ed1aab6"
+checksum = "8cf2dd12af7a047ad9d6da2b6b249759a22a7abc0f474c1dae1777afa4b21a73"
 dependencies = [
  "anstream",
  "anstyle",
@@ -875,14 +877,14 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b82cf0babdbd58558212896d1a4272303a57bdb245c2bf1147185fb45640e70"
+checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
 [[package]]
 name = "coins-bip32"
@@ -938,9 +940,9 @@ dependencies = [
 
 [[package]]
 name = "colorchoice"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"
+checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0"
 
 [[package]]
 name = "console"
@@ -976,9 +978,9 @@ checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
 
 [[package]]
 name = "constant_time_eq"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
 
 [[package]]
 name = "convert_case"
@@ -998,15 +1000,15 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.12"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
 dependencies = [
  "libc",
 ]
@@ -1140,7 +1142,7 @@ dependencies = [
  "cpufeatures",
  "curve25519-dalek-derive",
  "fiat-crypto",
- "rustc_version 0.4.0",
+ "rustc_version 0.4.1",
  "subtle",
  "zeroize",
 ]
@@ -1153,14 +1155,14 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
 name = "darling"
-version = "0.20.9"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83b2eb4d90d12bdda5ed17de686c2acb4c57914f8f921b8da7e112b5a36f3fe1"
+checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
  "darling_core",
  "darling_macro",
@@ -1168,27 +1170,27 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.20.9"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622687fe0bac72a04e5599029151f5796111b90f1baaa9b544d807a5e31cd120"
+checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.20.9"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -1231,8 +1233,8 @@ dependencies = [
  "convert_case",
  "proc-macro2",
  "quote",
- "rustc_version 0.4.0",
- "syn 2.0.68",
+ "rustc_version 0.4.1",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -1264,9 +1266,9 @@ checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
 
 [[package]]
 name = "dunce"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56ce8c6da7551ec6c462cbaf3bfbc75131ebbfa1c944aeaa9dab51ca1c5f0c3b"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
 
 [[package]]
 name = "ecdsa"
@@ -1284,9 +1286,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.12.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
 [[package]]
 name = "elf"
@@ -1495,7 +1497,7 @@ dependencies = [
  "regex",
  "serde",
  "serde_json",
- "syn 2.0.68",
+ "syn 2.0.77",
  "toml",
  "walkdir",
 ]
@@ -1513,7 +1515,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde_json",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -1531,7 +1533,7 @@ dependencies = [
  "ethabi",
  "generic-array",
  "k256",
- "num_enum 0.7.2",
+ "num_enum 0.7.3",
  "once_cell",
  "open-fastrlp",
  "rand",
@@ -1539,7 +1541,7 @@ dependencies = [
  "serde",
  "serde_json",
  "strum",
- "syn 2.0.68",
+ "syn 2.0.77",
  "tempfile",
  "thiserror",
  "tiny-keccak",
@@ -1639,9 +1641,9 @@ dependencies = [
 
 [[package]]
 name = "fastrand"
-version = "2.1.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
 
 [[package]]
 name = "fastrlp"
@@ -1799,7 +1801,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -1881,17 +1883,17 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.29.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
+checksum = "32085ea23f3234fc7846555e85283ba4de91e21016dc0455a16286d87a292d64"
 
 [[package]]
 name = "git2"
-version = "0.18.3"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "232e6a7bfe35766bf715e55a88b39a700596c0ccfd88cd3680b4cdb40d66ef70"
+checksum = "b903b73e45dc0c6c596f2d37eccece7c1c8bb6e4407b001096387c63d0d93724"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "libc",
  "libgit2-sys",
  "log",
@@ -1951,7 +1953,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http 0.2.12",
- "indexmap 2.2.6",
+ "indexmap 2.5.0",
  "slab",
  "tokio",
  "tokio-util",
@@ -2029,6 +2031,12 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
 
+[[package]]
+name = "hermit-abi"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
+
 [[package]]
 name = "hex"
 version = "0.4.3"
@@ -2094,9 +2102,9 @@ dependencies = [
 
 [[package]]
 name = "http-body"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
  "bytes",
  "http 1.1.0",
@@ -2111,7 +2119,7 @@ dependencies = [
  "bytes",
  "futures-util",
  "http 1.1.0",
- "http-body 1.0.0",
+ "http-body 1.0.1",
  "pin-project-lite",
 ]
 
@@ -2138,9 +2146,9 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "0.14.29"
+version = "0.14.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f361cde2f109281a220d4307746cdfd5ee3f410da58a70377762396775634b33"
+checksum = "a152ddd61dfaec7273fe8419ab357f33aee0d914c5f4efbf0d96fa749eea5ec9"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -2162,15 +2170,15 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.3.1"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe575dd17d0862a9a33781c8c4696a55c320909004a67a00fb286ba8b1bc496d"
+checksum = "50dfd22e0e76d0f662d429a5f80fcaf3855009297eab6a0a9f8543834744ba05"
 dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
  "http 1.1.0",
- "http-body 1.0.0",
+ "http-body 1.0.1",
  "httparse",
  "httpdate",
  "itoa",
@@ -2182,13 +2190,13 @@ dependencies = [
 
 [[package]]
 name = "hyper-rustls"
-version = "0.27.2"
+version = "0.27.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ee4be2c948921a1a5320b629c4193916ed787a7f7f293fd3f7f5a6c9de74155"
+checksum = "08afdbb5c31130e3034af566421053ab03787c640246a446327f550d11bcb333"
 dependencies = [
  "futures-util",
  "http 1.1.0",
- "hyper 1.3.1",
+ "hyper 1.4.1",
  "hyper-util",
  "rustls",
  "rustls-pki-types",
@@ -2200,16 +2208,16 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.5"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b875924a60b96e5d7b9ae7b066540b1dd1cbd90d1828f54c92e02a283351c56"
+checksum = "da62f120a8a37763efb0cf8fdf264b884c7b8b9ac8660b900c8661030c00e6ba"
 dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
  "http 1.1.0",
- "http-body 1.0.0",
- "hyper 1.3.1",
+ "http-body 1.0.1",
+ "hyper 1.4.1",
  "pin-project-lite",
  "socket2",
  "tokio",
@@ -2314,9 +2322,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.2.6"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5"
 dependencies = [
  "equivalent",
  "hashbrown 0.14.5",
@@ -2356,26 +2364,26 @@ dependencies = [
 
 [[package]]
 name = "ipnet"
-version = "2.9.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
+checksum = "187674a687eed5fe42285b40c6291f9a01517d415fad1c3cbc6a9f778af7fcd4"
 
 [[package]]
 name = "is-terminal"
-version = "0.4.12"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.4.0",
  "libc",
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.0"
+version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
 [[package]]
 name = "itertools"
@@ -2403,18 +2411,18 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jobserver"
-version = "0.1.31"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -2472,9 +2480,9 @@ dependencies = [
 
 [[package]]
 name = "keccak-asm"
-version = "0.1.1"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47a3633291834c4fbebf8673acbc1b04ec9d151418ff9b8e26dcd79129928758"
+checksum = "505d1856a39b200489082f90d897c3f07c455563880bc5952e38eabf731c83b6"
 dependencies = [
  "digest 0.10.7",
  "sha3-asm",
@@ -2497,15 +2505,15 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
 
 [[package]]
 name = "libgit2-sys"
-version = "0.16.2+1.7.2"
+version = "0.17.0+1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee4126d8b4ee5c9d9ea891dd875cfdc1e9d0950437179104b183d7d8a74d24e8"
+checksum = "10472326a8a6477c3c20a64547b0059e4b0d086869eee31e6d7da728a8eb7224"
 dependencies = [
  "cc",
  "libc",
@@ -2515,12 +2523,12 @@ dependencies = [
 
 [[package]]
 name = "libloading"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e310b3a6b5907f99202fcdb4960ff45b93735d7c7d96b760fcff8db2dc0e103d"
+checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -2531,9 +2539,9 @@ checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
 
 [[package]]
 name = "libz-sys"
-version = "1.1.18"
+version = "1.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c15da26e5af7e25c90b37a2d75cdbf940cf4a55316de9d84c679c9b8bfabf82e"
+checksum = "d2d16453e800a8cf6dd2fc3eb4bc99b786a9b90c663b8559a5b1a041bf89e472"
 dependencies = [
  "cc",
  "libc",
@@ -2604,20 +2612,20 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.7.4"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08"
+checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
 dependencies = [
- "adler",
+ "adler2",
 ]
 
 [[package]]
 name = "mio"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4569e456d394deccd22ce1c1913e6ea0e54519f577285001215d33557431afe4"
+checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.3.9",
  "libc",
  "wasi",
  "windows-sys 0.52.0",
@@ -2748,7 +2756,7 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.3.9",
  "libc",
 ]
 
@@ -2763,11 +2771,11 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02339744ee7253741199f897151b38e72257d13802d4ee837285cc2990a90845"
+checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179"
 dependencies = [
- "num_enum_derive 0.7.2",
+ "num_enum_derive 0.7.3",
 ]
 
 [[package]]
@@ -2784,14 +2792,14 @@ dependencies = [
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b"
+checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
 dependencies = [
- "proc-macro-crate 3.1.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -2811,9 +2819,9 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
 
 [[package]]
 name = "object"
-version = "0.36.0"
+version = "0.36.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "576dfe1fc8f9df304abb159d767a29d0476f7750fbf8aa7ad07816004a207434"
+checksum = "084f1a5821ac4c651660a94a7153d27ac9d8a53736203f58b31945ded098070a"
 dependencies = [
  "memchr",
 ]
@@ -2826,9 +2834,9 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "oorandom"
-version = "11.1.3"
+version = "11.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+checksum = "b410bbe7e14ab526a0e86877eb47c6996a2bd7746f027ba551028c925390e4e9"
 
 [[package]]
 name = "open-fastrlp"
@@ -2864,7 +2872,7 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 [[package]]
 name = "p3-air"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "p3-field",
  "p3-matrix",
@@ -2873,7 +2881,7 @@ dependencies = [
 [[package]]
 name = "p3-baby-bear"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "num-bigint 0.4.6",
  "p3-field",
@@ -2887,7 +2895,7 @@ dependencies = [
 [[package]]
 name = "p3-blake3"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "blake3",
  "p3-symmetric",
@@ -2896,7 +2904,7 @@ dependencies = [
 [[package]]
 name = "p3-bn254-fr"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "ff 0.13.0",
  "num-bigint 0.4.6",
@@ -2910,7 +2918,7 @@ dependencies = [
 [[package]]
 name = "p3-challenger"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "p3-field",
  "p3-maybe-rayon",
@@ -2922,7 +2930,7 @@ dependencies = [
 [[package]]
 name = "p3-commit"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "itertools 0.12.1",
  "p3-challenger",
@@ -2935,7 +2943,7 @@ dependencies = [
 [[package]]
 name = "p3-dft"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "p3-field",
  "p3-matrix",
@@ -2947,7 +2955,7 @@ dependencies = [
 [[package]]
 name = "p3-field"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "itertools 0.12.1",
  "num-bigint 0.4.6",
@@ -2960,7 +2968,7 @@ dependencies = [
 [[package]]
 name = "p3-fri"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "itertools 0.12.1",
  "p3-challenger",
@@ -2978,7 +2986,7 @@ dependencies = [
 [[package]]
 name = "p3-interpolation"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "p3-field",
  "p3-matrix",
@@ -2988,7 +2996,7 @@ dependencies = [
 [[package]]
 name = "p3-keccak"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "p3-symmetric",
  "tiny-keccak",
@@ -2997,7 +3005,7 @@ dependencies = [
 [[package]]
 name = "p3-keccak-air"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "p3-air",
  "p3-field",
@@ -3010,7 +3018,7 @@ dependencies = [
 [[package]]
 name = "p3-matrix"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "itertools 0.12.1",
  "p3-field",
@@ -3024,7 +3032,7 @@ dependencies = [
 [[package]]
 name = "p3-maybe-rayon"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "rayon",
 ]
@@ -3032,7 +3040,7 @@ dependencies = [
 [[package]]
 name = "p3-mds"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "itertools 0.12.1",
  "p3-dft",
@@ -3046,7 +3054,7 @@ dependencies = [
 [[package]]
 name = "p3-merkle-tree"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "itertools 0.12.1",
  "p3-commit",
@@ -3062,7 +3070,7 @@ dependencies = [
 [[package]]
 name = "p3-poseidon2"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "gcd",
  "p3-field",
@@ -3074,7 +3082,7 @@ dependencies = [
 [[package]]
 name = "p3-symmetric"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "itertools 0.12.1",
  "p3-field",
@@ -3084,7 +3092,7 @@ dependencies = [
 [[package]]
 name = "p3-uni-stark"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "itertools 0.12.1",
  "p3-air",
@@ -3102,7 +3110,7 @@ dependencies = [
 [[package]]
 name = "p3-util"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#b75d346d549d47ad91afcb6bb18ef757850c13c7"
+source = "git+https://github.com/argumentcomputer/Plonky3.git?branch=sp1#a0b9287038ab11e165c78df1fbc2402609a7d6b5"
 dependencies = [
  "serde",
 ]
@@ -3145,7 +3153,7 @@ version = "3.6.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d830939c76d294956402033aee57a6da7b438f2294eb94864c37b0569053a42c"
 dependencies = [
- "proc-macro-crate 3.1.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
  "syn 1.0.109",
@@ -3246,9 +3254,9 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.7.10"
+version = "2.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "560131c633294438da9f7c4b08189194b20946c8274c6b9e38881a7874dc8ee8"
+checksum = "9c73c26c01b8c87956cea613c907c9d6ecffd8d18a2a5908e5de0adfaa185cea"
 dependencies = [
  "memchr",
  "thiserror",
@@ -3262,7 +3270,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e9567389417feee6ce15dd6527a8a1ecac205ef62c2932bcf3d9f6fc5b78b414"
 dependencies = [
  "futures",
- "rustc_version 0.4.0",
+ "rustc_version 0.4.1",
 ]
 
 [[package]]
@@ -3282,7 +3290,7 @@ checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -3315,9 +3323,9 @@ checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
 
 [[package]]
 name = "plotters"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a15b6eccb8484002195a3e44fe65a4ce8e93a625797a063735536fd59cb01cf3"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
 dependencies = [
  "num-traits",
  "plotters-backend",
@@ -3328,24 +3336,24 @@ dependencies = [
 
 [[package]]
 name = "plotters-backend"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "414cec62c6634ae900ea1c56128dfe87cf63e7caece0852ec76aba307cebadb7"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
 
 [[package]]
 name = "plotters-svg"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81b30686a7d9c3e010b84284bdd26a29f2138574f52f5eb6f794fc0ad924e705"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
 dependencies = [
  "plotters-backend",
 ]
 
 [[package]]
 name = "portable-atomic"
-version = "1.6.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
+checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
 
 [[package]]
 name = "powerfmt"
@@ -3355,18 +3363,21 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.17"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
 
 [[package]]
 name = "prettyplease"
-version = "0.2.20"
+version = "0.2.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e"
+checksum = "479cf940fbbb3426c32c5d5176f62ad57549a0bb84773423ba8be9d089f5faba"
 dependencies = [
  "proc-macro2",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -3395,11 +3406,11 @@ dependencies = [
 
 [[package]]
 name = "proc-macro-crate"
-version = "3.1.0"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284"
+checksum = "8ecf48c7ca261d60b74ab1a7b20da18bede46776b2e55535cb958eb595c5fa7b"
 dependencies = [
- "toml_edit 0.21.1",
+ "toml_edit 0.22.20",
 ]
 
 [[package]]
@@ -3443,7 +3454,7 @@ checksum = "b4c2511913b88df1637da85cc8d96ec8e43a3f8bb8ccb71ee1ac240d6f3df58d"
 dependencies = [
  "bit-set",
  "bit-vec",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "lazy_static",
  "num-traits",
  "rand",
@@ -3472,10 +3483,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "81bddcdb20abf9501610992b6759a4c888aef7d1a7247ef75e2404275ac24af1"
 dependencies = [
  "anyhow",
- "itertools 0.10.5",
+ "itertools 0.12.1",
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -3486,16 +3497,17 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 
 [[package]]
 name = "quinn"
-version = "0.11.2"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4ceeeeabace7857413798eb1ffa1e9c905a9946a57d81fb69b4b71c4d8eb3ad"
+checksum = "8c7c5fdde3cdae7203427dc4f0a68fe0ed09833edc525a03456b153b79828684"
 dependencies = [
  "bytes",
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
- "rustc-hash",
+ "rustc-hash 2.0.0",
  "rustls",
+ "socket2",
  "thiserror",
  "tokio",
  "tracing",
@@ -3503,14 +3515,14 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.3"
+version = "0.11.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddf517c03a109db8100448a4be38d498df8a210a99fe0e1b9eaf39e78c640efe"
+checksum = "fadfaed2cd7f389d0161bb73eeb07b7b78f8691047a6f3e73caaeae55310a4a6"
 dependencies = [
  "bytes",
  "rand",
  "ring 0.17.8",
- "rustc-hash",
+ "rustc-hash 2.0.0",
  "rustls",
  "slab",
  "thiserror",
@@ -3520,22 +3532,22 @@ dependencies = [
 
 [[package]]
 name = "quinn-udp"
-version = "0.5.2"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9096629c45860fc7fb143e125eb826b5e721e10be3263160c7d60ca832cf8c46"
+checksum = "4fe68c2e9e1a1234e218683dbdf9f9dfcb094113c5ac2b938dfcb9bab4c4140b"
 dependencies = [
  "libc",
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
  "proc-macro2",
 ]
@@ -3616,18 +3628,18 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.2"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
+checksum = "0884ad60e090bf1345b93da0a5de8923c93884cd03f40dfcfddd3b4bee661853"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
 name = "regex"
-version = "1.10.5"
+version = "1.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -3681,7 +3693,7 @@ dependencies = [
  "h2",
  "http 0.2.12",
  "http-body 0.4.6",
- "hyper 0.14.29",
+ "hyper 0.14.30",
  "ipnet",
  "js-sys",
  "log",
@@ -3700,23 +3712,23 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
- "winreg 0.50.0",
+ "winreg",
 ]
 
 [[package]]
 name = "reqwest"
-version = "0.12.5"
+version = "0.12.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7d6d2a27d57148378eb5e111173f4276ad26340ecc5c49a4a2152167a2d6a37"
+checksum = "f8f4955649ef5c38cc7f9e8aa41761d48fb9677197daea9984dc54f56aad5e63"
 dependencies = [
  "base64 0.22.1",
  "bytes",
  "futures-core",
  "futures-util",
  "http 1.1.0",
- "http-body 1.0.0",
+ "http-body 1.0.1",
  "http-body-util",
- "hyper 1.3.1",
+ "hyper 1.4.1",
  "hyper-rustls",
  "hyper-util",
  "ipnet",
@@ -3744,7 +3756,7 @@ dependencies = [
  "wasm-streams",
  "web-sys",
  "webpki-roots",
- "winreg 0.52.0",
+ "windows-registry",
 ]
 
 [[package]]
@@ -3756,7 +3768,7 @@ dependencies = [
  "anyhow",
  "async-trait",
  "http 1.1.0",
- "reqwest 0.12.5",
+ "reqwest 0.12.7",
  "serde",
  "thiserror",
  "tower-service",
@@ -3885,6 +3897,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"
+
 [[package]]
 name = "rustc-hex"
 version = "2.1.0"
@@ -3902,20 +3920,20 @@ dependencies = [
 
 [[package]]
 name = "rustc_version"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
  "semver 1.0.23",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.38.34"
+version = "0.38.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -3924,9 +3942,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.12"
+version = "0.23.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c58f8c84392efc0a126acce10fa59ff7b3d2ac06ab451a33f2741989b806b044"
+checksum = "f2dabaac7466917e566adb06783a81ca48944c6898a1b08b9374106dd671f4c8"
 dependencies = [
  "once_cell",
  "ring 0.17.8",
@@ -3938,9 +3956,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-pemfile"
-version = "2.1.2"
+version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29993a25686778eb88d4189742cd713c9bce943bc54251a33509dc63cbacf73d"
+checksum = "196fe16b00e106300d3e45ecfcb764fa292a535d7326a29a5875c579c7417425"
 dependencies = [
  "base64 0.22.1",
  "rustls-pki-types",
@@ -3948,15 +3966,15 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976295e77ce332211c0d24d92c0e83e50f5c5f046d11082cea19f3df13a3562d"
+checksum = "fc0a2ce646f8655401bb81e7927b812614bd5d91dbc968696be50603510fcaf0"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.102.6"
+version = "0.102.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e6b52d4fda176fd835fdc55a835d4a89b8499cad995885a21149d5ad62f852e"
+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
 dependencies = [
  "ring 0.17.8",
  "rustls-pki-types",
@@ -4023,7 +4041,7 @@ version = "2.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2d35494501194174bda522a32605929eefc9ecf7e0a326c26db1fdd85881eb62"
 dependencies = [
- "proc-macro-crate 3.1.0",
+ "proc-macro-crate 3.2.0",
  "proc-macro2",
  "quote",
  "syn 1.0.109",
@@ -4031,9 +4049,9 @@ dependencies = [
 
 [[package]]
 name = "scc"
-version = "2.1.1"
+version = "2.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76ad2bbb0ae5100a07b7a6f2ed7ab5fd0045551a4c507989b7a620046ea3efdc"
+checksum = "0c947adb109a8afce5fc9c7bf951f87f146e9147b3a6a58413105628fb1d1e66"
 dependencies = [
  "sdd",
 ]
@@ -4058,9 +4076,9 @@ dependencies = [
 
 [[package]]
 name = "sdd"
-version = "0.2.0"
+version = "3.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b84345e4c9bd703274a082fb80caaa99b7612be48dfaa1dd9266577ec412309d"
+checksum = "60a7b59a5d9b0099720b417b6325d91a52cbf5b3dcb5041d864be53eefa58abc"
 
 [[package]]
 name = "sec1"
@@ -4117,29 +4135,29 @@ checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
 
 [[package]]
 name = "serde"
-version = "1.0.207"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5665e14a49a4ea1b91029ba7d3bca9f299e1f7cfa194388ccc20f14743e784f2"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.207"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6aea2634c86b0e8ef2cfdc0c340baede54ec27b1e46febd7f80dffb2aa44a00e"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.124"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66ad62847a56b3dba58cc891acd13884b9c61138d330c0d7b6181713d4fce38d"
+checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
 dependencies = [
  "itoa",
  "memchr",
@@ -4159,9 +4177,9 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.6"
+version = "0.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79e674e01f999af37c49f70a6ede167a8a60b2503e56c5599532a65baa5969a0"
+checksum = "eb5b1b31579f3811bf615c144393417496f152e12ac8b7663bf664f4a815306d"
 dependencies = [
  "serde",
 ]
@@ -4188,7 +4206,7 @@ dependencies = [
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.2.6",
+ "indexmap 2.5.0",
  "serde",
  "serde_derive",
  "serde_json",
@@ -4205,7 +4223,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -4230,7 +4248,7 @@ checksum = "82fe9db325bcef1fbcde82e078a5cc4efdf787e96b3b9cf45b50b529f2083d67"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -4266,9 +4284,9 @@ dependencies = [
 
 [[package]]
 name = "sha3-asm"
-version = "0.1.1"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9b57fd861253bff08bb1919e995f90ba8f4889de2726091c8876f3a4e823b40"
+checksum = "c28efc5e327c837aa837c59eae585fc250715ef939ac32881bcc11677cd02d46"
 dependencies = [
  "cc",
  "cfg-if",
@@ -4364,7 +4382,7 @@ dependencies = [
  "home",
  "indicatif",
  "rand",
- "reqwest 0.12.5",
+ "reqwest 0.12.7",
  "serde",
  "serde_json",
  "sphinx-core",
@@ -4482,6 +4500,20 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "sphinx-precompiles"
+version = "1.0.0"
+source = "git+https://github.com/argumentcomputer/sphinx?branch=dev#f51436fe14e6d029313546e8284cf6762f81f776"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "hybrid-array",
+ "k256",
+ "serde",
+]
+
 [[package]]
 name = "sphinx-primitives"
 version = "1.0.0"
@@ -4514,7 +4546,7 @@ dependencies = [
  "p3-commit",
  "p3-field",
  "rayon",
- "reqwest 0.12.5",
+ "reqwest 0.12.7",
  "serde",
  "serde_json",
  "serial_test",
@@ -4712,7 +4744,7 @@ dependencies = [
  "p3-fri",
  "p3-matrix",
  "prost",
- "reqwest 0.12.5",
+ "reqwest 0.12.7",
  "reqwest-middleware",
  "serde",
  "serde_json",
@@ -4744,7 +4776,7 @@ dependencies = [
  "p3-field",
  "rand",
  "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
- "sphinx-precompiles",
+ "sphinx-precompiles 1.0.0",
  "sphinx-primitives",
 ]
 
@@ -4801,14 +4833,14 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
 name = "subtle"
-version = "2.6.0"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d0208408ba0c3df17ed26eb06992cb1a1268d41b2c0e12e65203fbe3972cee5"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "subtle-encoding"
@@ -4832,9 +4864,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.68"
+version = "2.0.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4850,7 +4882,7 @@ dependencies = [
  "paste",
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -4864,6 +4896,9 @@ name = "sync_wrapper"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394"
+dependencies = [
+ "futures-core",
+]
 
 [[package]]
 name = "system-configuration"
@@ -4928,7 +4963,7 @@ checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -4995,9 +5030,9 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.6.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -5010,9 +5045,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.39.2"
+version = "1.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "daa4fb1bc778bd6f04cbfc4bb2d06a7396a8f299dc33ea1900cedaa316f467b1"
+checksum = "e2b070231665d27ad9ec9b8df639893f46727666c6767db40317fbe920a5d998"
 dependencies = [
  "backtrace",
  "bytes",
@@ -5034,7 +5069,7 @@ checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -5050,9 +5085,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.11"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
+checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
 dependencies = [
  "bytes",
  "futures-core",
@@ -5063,21 +5098,21 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.8.14"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f49eb2ab21d2f26bd6db7bf383edc527a7ebaee412d17af4d40fdccd442f335"
+checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
 dependencies = [
  "serde",
  "serde_spanned",
  "toml_datetime",
- "toml_edit 0.22.14",
+ "toml_edit 0.22.20",
 ]
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.6"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
+checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
 dependencies = [
  "serde",
 ]
@@ -5088,33 +5123,22 @@ version = "0.19.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
- "indexmap 2.2.6",
+ "indexmap 2.5.0",
  "toml_datetime",
  "winnow 0.5.40",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.21.1"
+version = "0.22.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
+checksum = "583c44c02ad26b0c3f3066fe629275e50627026c51ac2e595cca4c230ce1ce1d"
 dependencies = [
- "indexmap 2.2.6",
- "toml_datetime",
- "winnow 0.5.40",
-]
-
-[[package]]
-name = "toml_edit"
-version = "0.22.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f21c7aaf97f1bd9ca9d4f9e73b0a6c74bd5afef56f2bc931943a6e1c37e04e38"
-dependencies = [
- "indexmap 2.2.6",
+ "indexmap 2.5.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
- "winnow 0.6.13",
+ "winnow 0.6.18",
 ]
 
 [[package]]
@@ -5135,15 +5159,15 @@ dependencies = [
 
 [[package]]
 name = "tower-layer"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
 
 [[package]]
 name = "tower-service"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
@@ -5165,7 +5189,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -5262,9 +5286,9 @@ dependencies = [
  "futures",
  "http 1.1.0",
  "http-body-util",
- "hyper 1.3.1",
+ "hyper 1.4.1",
  "prost",
- "reqwest 0.12.5",
+ "reqwest 0.12.7",
  "serde",
  "serde_json",
  "thiserror",
@@ -5311,9 +5335,9 @@ checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
 
 [[package]]
 name = "unicode-normalization"
@@ -5332,9 +5356,9 @@ checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
 
 [[package]]
 name = "unicode-xid"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+checksum = "229730647fbc343e3a80e463c1db7f78f3855d3f3739bee0dda773c9a037c90a"
 
 [[package]]
 name = "untrusted"
@@ -5389,9 +5413,9 @@ checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
 name = "vergen"
-version = "8.3.1"
+version = "8.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e27d6bdd219887a9eadd19e1c34f32e47fa332301184935c6d9bca26f3cca525"
+checksum = "2990d9ea5967266ea0ccf413a4aa5c42a93dbcfda9cb49a97de6931726b12566"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -5402,9 +5426,9 @@ dependencies = [
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "wait-timeout"
@@ -5442,34 +5466,35 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
 dependencies = [
  "cfg-if",
+ "once_cell",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.42"
+version = "0.4.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
+checksum = "61e9300f63a621e96ed275155c108eb6f843b6a26d053f122ab69724559dc8ed"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -5479,9 +5504,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -5489,22 +5514,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
 
 [[package]]
 name = "wasm-streams"
@@ -5521,9 +5546,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.69"
+version = "0.3.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
+checksum = "26fdeaafd9bd129f65e7c031593c24d62186301e0c72c8978fa1678be7d532c0"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -5541,9 +5566,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-roots"
-version = "0.26.3"
+version = "0.26.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd7c23921eeb1713a4e851530e9b9756e4fb0e89978582942612524cf09f01cd"
+checksum = "0bd24728e5af82c6c4ec1b66ac4844bdf8156257fccda846ec58b42cd0cdbe6a"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -5578,11 +5603,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5600,6 +5625,36 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-registry"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e400001bb720a623c1c69032f8e3e4cf09984deec740f007dd2b03ec864804b0"
+dependencies = [
+ "windows-result",
+ "windows-strings",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
+dependencies = [
+ "windows-result",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -5759,9 +5814,9 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.6.13"
+version = "0.6.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59b5e5f6c299a3c7890b876a2a587f3115162487e704907d9b6cd29473052ba1"
+checksum = "68a9bda4691f099d435ad181000724da8e5899daa10713c2d432552b9ccd3a6f"
 dependencies = [
  "memchr",
 ]
@@ -5776,16 +5831,6 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
-[[package]]
-name = "winreg"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a277a57398d4bfa075df44f501a17cfdf8542d224f0d36095a2adc7aee4ef0a5"
-dependencies = [
- "cfg-if",
- "windows-sys 0.48.0",
-]
-
 [[package]]
 name = "ws_stream_wasm"
 version = "0.7.4"
@@ -5797,7 +5842,7 @@ dependencies = [
  "js-sys",
  "log",
  "pharos",
- "rustc_version 0.4.0",
+ "rustc_version 0.4.1",
  "send_wrapper 0.6.0",
  "thiserror",
  "wasm-bindgen",
@@ -5822,22 +5867,23 @@ checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
 [[package]]
 name = "zerocopy"
-version = "0.7.34"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae87e3fcd617500e5d106f0380cf7b77f3c6092aae37191433159dda23cfb087"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
+ "byteorder",
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.34"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15e934569e47891f7d9411f1a451d947a60e000ab3bd24fbb970f000387d1b3b"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
@@ -5857,7 +5903,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.68",
+ "syn 2.0.77",
 ]
 
 [[package]]
diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index 50ace6dd2..4f177f8eb 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -10,7 +10,10 @@ use super::{program::Program, Opcode};
 use crate::runtime::MemoryInitializeFinalizeEvent;
 use crate::runtime::MemoryRecordEnum;
 use crate::stark::MachineRecord;
-use crate::syscall::precompiles::blake2s::{Blake2sXorRotateRightChip, Blake2sXorRotateRightEvent};
+use crate::syscall::precompiles::blake2s::{
+    Blake2sXorRotate16Chip, Blake2sXorRotate16Event, Blake2sXorRotateRightChip,
+    Blake2sXorRotateRightEvent,
+};
 use crate::syscall::precompiles::edwards::EdDecompressEvent;
 use crate::syscall::precompiles::keccak256::KeccakPermuteEvent;
 use crate::syscall::precompiles::sha256::{ShaCompressEvent, ShaExtendEvent};
@@ -127,6 +130,7 @@ pub struct ExecutionRecord {
     pub bls12381_g2_double_events: Vec<Bls12381G2AffineDoubleEvent>,
 
     pub blake2s_xor_rotate_right_events: Vec<Blake2sXorRotateRightEvent>,
+    pub blake2s_xor_rotate_16_events: Vec<Blake2sXorRotate16Event>,
 
     pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
 
@@ -327,6 +331,12 @@ impl EventLens<Blake2sXorRotateRightChip> for ExecutionRecord {
     }
 }
 
+impl EventLens<Blake2sXorRotate16Chip> for ExecutionRecord {
+    fn events(&self) -> <Blake2sXorRotate16Chip as crate::air::WithEvents<'_>>::Events {
+        &self.blake2s_xor_rotate_16_events
+    }
+}
+
 pub struct ShardingConfig {
     pub shard_size: usize,
     pub add_len: usize,
@@ -478,6 +488,11 @@ impl MachineRecord for ExecutionRecord {
             "blake2s_xor_rotate_right_events".to_string(),
             self.blake2s_xor_rotate_right_events.len(),
         );
+        stats.insert(
+            "blake2s_xor_rotate_16_events".to_string(),
+            self.blake2s_xor_rotate_16_events.len(),
+        );
+
         stats
     }
 
@@ -525,6 +540,8 @@ impl MachineRecord for ExecutionRecord {
             .append(&mut other.bls12381_g2_double_events);
         self.blake2s_xor_rotate_right_events
             .append(&mut other.blake2s_xor_rotate_right_events);
+        self.blake2s_xor_rotate_16_events
+            .append(&mut other.blake2s_xor_rotate_16_events);
 
         // Merge the byte lookups.
         for (shard, events_map) in take(&mut other.byte_lookups) {
@@ -858,6 +875,12 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
+        // blake2s_xor_rotate_16 events
+        first.blake2s_xor_rotate_16_events = take(&mut self.blake2s_xor_rotate_16_events);
+        for (i, event) in first.blake2s_xor_rotate_16_events.iter().enumerate() {
+            self.nonce_lookup.insert(event.lookup_id, (i * 48) as u32);
+        }
+
         // Put MemoryInit / MemoryFinalize events in the last shard.
         let last = shards.last_mut().unwrap();
         last.memory_initialize_events
diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 2f2372564..5127148e5 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -6,7 +6,7 @@ use strum_macros::EnumIter;
 
 use crate::runtime::{Register, Runtime};
 use crate::stark::Ed25519Parameters;
-use crate::syscall::precompiles::blake2s::Blake2sXorRotateRightChip;
+use crate::syscall::precompiles::blake2s::{Blake2sXorRotate16Chip, Blake2sXorRotateRightChip};
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::bls12_381::g2_add::Bls12381G2AffineAddChip;
 use crate::syscall::precompiles::bls12_381::g2_double::Bls12381G2AffineDoubleChip;
@@ -119,6 +119,8 @@ pub enum SyscallCode {
     HINT_READ = 0x00_00_00_F1,
 
     BLAKE_2S_XOR_ROTATE_RIGHT = 0x00_01_01_CC,
+
+    BLAKE_2S_XOR_ROTATE_16 = 0x00_30_01_CD,
 }
 
 impl SyscallCode {
@@ -156,6 +158,7 @@ impl SyscallCode {
             0x00_01_01_80 => SyscallCode::BLS12381_G2_ADD,
             0x00_00_01_81 => SyscallCode::BLS12381_G2_DOUBLE,
             0x00_01_01_CC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT,
+            0x00_30_01_CD => SyscallCode::BLAKE_2S_XOR_ROTATE_16,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -399,6 +402,11 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
         Arc::new(Blake2sXorRotateRightChip::new()),
     );
 
+    syscall_map.insert(
+        SyscallCode::BLAKE_2S_XOR_ROTATE_16,
+        Arc::new(Blake2sXorRotate16Chip::new()),
+    );
+
     syscall_map
 }
 
@@ -519,6 +527,10 @@ mod tests {
                         sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT
                     )
                 }
+
+                SyscallCode::BLAKE_2S_XOR_ROTATE_16 => {
+                    assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_16)
+                }
             }
         }
     }
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index 835709f3f..a3e9b272c 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -3,7 +3,7 @@ pub use crate::air::SphinxAirBuilder;
 use crate::air::{MachineAir, SPHINX_PROOF_NUM_PV_ELTS};
 use crate::memory::{MemoryChipType, MemoryProgramChip};
 use crate::stark::Chip;
-use crate::syscall::precompiles::blake2s::Blake2sXorRotateRightChip;
+use crate::syscall::precompiles::blake2s::{Blake2sXorRotate16Chip, Blake2sXorRotateRightChip};
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::field::FieldChip;
 use crate::syscall::precompiles::quad_field::QuadFieldChip;
@@ -109,6 +109,7 @@ pub enum RiscvAir<F: PrimeField32> {
     Bls12381G1Decompress(Bls12381G1DecompressChip),
 
     Blake2sXorRotateRight(Blake2sXorRotateRightChip),
+    Blake2sXorRotate16(Blake2sXorRotate16Chip),
 }
 
 impl<F: PrimeField32> RiscvAir<F> {
@@ -188,6 +189,9 @@ impl<F: PrimeField32> RiscvAir<F> {
         let blake_2s_xor_rotate_right = Blake2sXorRotateRightChip::default();
         chips.push(RiscvAir::Blake2sXorRotateRight(blake_2s_xor_rotate_right));
 
+        let blake_2s_xor_rotate_16 = Blake2sXorRotate16Chip::default();
+        chips.push(RiscvAir::Blake2sXorRotate16(blake_2s_xor_rotate_16));
+
         chips
     }
 }
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index beac20a1c..2ceaa8ac7 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -1,3 +1,7 @@
+mod xor_rotate_16;
+
+pub use xor_rotate_16::*;
+
 use crate::bytes::event::ByteRecord;
 use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
 use crate::operations::{FixedRotateRightOperation, XorOperation};
@@ -40,7 +44,6 @@ pub struct Blake2sXorRotateRightEvent {
     pub channel: u32,
     pub a_ptr: u32,
     pub b_ptr: u32,
-    pub rot: u32,
     pub a_reads_writes: Vec<MemoryWriteRecord>,
     pub b_reads: Vec<MemoryReadRecord>,
 }
@@ -56,10 +59,7 @@ impl Syscall for Blake2sXorRotateRightChip {
         let b_ptr = arg2;
 
         let a = ctx.slice_unsafe(a_ptr, 4);
-        let (b_reads, mut b) = ctx.mr_slice(b_ptr, 5);
-
-        let rot = b[4].clone();
-        b.truncate(4);
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 4);
 
         let xor = a
             .into_iter()
@@ -69,7 +69,7 @@ impl Syscall for Blake2sXorRotateRightChip {
 
         let rotate_right = xor
             .into_iter()
-            .map(|xor_i| xor_i.rotate_right(rot))
+            .map(|xor_i| xor_i.rotate_right(R_1))
             .collect::<Vec<u32>>();
 
         ctx.clk += 1;
@@ -86,7 +86,6 @@ impl Syscall for Blake2sXorRotateRightChip {
                 channel,
                 a_ptr,
                 b_ptr,
-                rot,
                 a_reads_writes,
                 b_reads,
             });
@@ -112,7 +111,7 @@ struct Blake2sXorRotateRightCols<T> {
     pub b_ptr: T,
 
     pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 5], // includes rotation constant
+    pub b: [MemoryReadCols<T>; 4],
 
     pub xor: [XorOperation<T>; 4],
     pub rotate_right: [FixedRotateRightOperation<T>; 4],
@@ -156,10 +155,6 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRightChip {
             cols.a_ptr = F::from_canonical_u32(event.a_ptr);
             cols.b_ptr = F::from_canonical_u32(event.b_ptr);
 
-            cols.b[4].populate(event.channel, event.b_reads[4], &mut new_byte_lookup_events); // handle rotation_constant
-
-            let rot = event.b_reads[4].value;
-
             for i in 0..4usize {
                 cols.a[i].populate(
                     event.channel,
@@ -172,11 +167,11 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRightChip {
                 let a = event.a_reads_writes[i].value;
                 let b = event.b_reads[i].value;
                 let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
-                //assert_eq!(a ^ b, xor);
+                assert_eq!(a ^ b, xor);
 
-                let _rotate_right =
-                    cols.rotate_right[i].populate(output, shard, event.channel, xor, rot as usize);
-                //assert_eq!(xor.rotate_right(rot), rotate_right);
+                let rotate_right =
+                    cols.rotate_right[i].populate(output, shard, event.channel, xor, R_1 as usize);
+                assert_eq!(xor.rotate_right(R_1), rotate_right);
             }
 
             rows.push(row);
@@ -225,20 +220,6 @@ where
             .when_transition()
             .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
 
-        // Eval rotation_constant (included as 4th word in b_ptr).
-        let i = 4usize;
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-            &local.b[i],
-            local.is_real,
-        );
-
-        // TODO: get rotation constant from memory somehow
-        //let _rot = *local.b[4].value();
-
         for i in 0..4usize {
             // Eval a
             builder.eval_memory_access(
@@ -275,7 +256,7 @@ where
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
                 local.xor[i].value,
-                R_1 as usize, // TODO use value from memory instead !
+                R_1 as usize,
                 local.rotate_right[i],
                 local.shard,
                 &local.channel,
@@ -299,12 +280,11 @@ where
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::syscall::precompiles::blake2s::R_1;
     use crate::utils::tests::BLAKE2S_XOR_RIGHT_ROTATE_ELF;
     use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 5]) -> Program {
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
         let mut instructions = vec![];
         // memory write a
         for (index, word) in a.into_iter().enumerate() {
@@ -359,7 +339,7 @@ mod tests {
             a_ptr,
             b_ptr,
             [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, R_1],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
         );
 
         let (_, memory) = run_test_with_memory_inspection(program);
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/air.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/air.rs
new file mode 100644
index 000000000..3ddd0f4f7
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/xor_rotate_16/air.rs
@@ -0,0 +1,291 @@
+use core::borrow::Borrow;
+
+use p3_air::{Air, AirBuilder, BaseAir};
+use p3_field::AbstractField;
+use p3_matrix::Matrix;
+
+use super::{Blake2sXorRotate16Chip, Blake2sXorRotate16Cols, NUM_BLAKE2S_XOR_ROTATE_16_COLS};
+use crate::{
+    air::{AluAirBuilder, BaseAirBuilder, MemoryAirBuilder, WordAirBuilder},
+    memory::MemoryCols,
+    operations::{FixedRotateRightOperation, XorOperation},
+    runtime::SyscallCode,
+};
+
+impl<F> BaseAir<F> for Blake2sXorRotate16Chip {
+    fn width(&self) -> usize {
+        NUM_BLAKE2S_XOR_ROTATE_16_COLS
+    }
+}
+
+impl<AB> Air<AB> for Blake2sXorRotate16Chip
+where
+    AB: MemoryAirBuilder + AluAirBuilder + WordAirBuilder,
+{
+    fn eval(&self, builder: &mut AB) {
+        // Initialize columns.
+        let main = builder.main();
+        let (local, next) = (main.row_slice(0), main.row_slice(1));
+        let local: &Blake2sXorRotate16Cols<AB::Var> = (*local).borrow();
+        let next: &Blake2sXorRotate16Cols<AB::Var> = (*next).borrow();
+
+        // Constrain the incrementing nonce.
+        builder.when_first_row().assert_zero(local.nonce);
+        builder
+            .when_transition()
+            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
+
+        let i_start = AB::F::from_canonical_u32(16);
+
+        // Evaluate the control flags.
+        self.eval_flags(builder);
+
+        // Copy over the inputs until the result has been computed (every 48 rows).
+        builder
+            .when_transition()
+            .when_not(local.cycle_16_end.result * local.cycle_48[2])
+            .assert_eq(local.shard, next.shard);
+        builder
+            .when_transition()
+            .when_not(local.cycle_16_end.result * local.cycle_48[2])
+            .assert_eq(local.clk, next.clk);
+        builder
+            .when_transition()
+            .when_not(local.cycle_16_end.result * local.cycle_48[2])
+            .assert_eq(local.channel, next.channel);
+        builder
+            .when_transition()
+            .when_not(local.cycle_16_end.result * local.cycle_48[2])
+            .assert_eq(local.w_ptr, next.w_ptr);
+
+        // Read w[0].
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(0),
+            &local.w_0,
+            local.is_real,
+        );
+
+        // Read w[1]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(4),
+            &local.w_1,
+            local.is_real,
+        );
+
+        // Read w[2]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(8),
+            &local.w_2,
+            local.is_real,
+        );
+
+        // Read w[3]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(12),
+            &local.w_3,
+            local.is_real,
+        );
+
+        // Read w[4]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(16),
+            &local.w_4,
+            local.is_real,
+        );
+
+        // Read w[5]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(20),
+            &local.w_5,
+            local.is_real,
+        );
+
+        // Read w[6]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(24),
+            &local.w_6,
+            local.is_real,
+        );
+
+        // Read w[7]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(28),
+            &local.w_7,
+            local.is_real,
+        );
+
+        XorOperation::<AB::F>::eval(
+            builder,
+            *local.w_0.value(),
+            *local.w_4.value(),
+            local.xor_0,
+            local.shard,
+            &local.channel,
+            local.is_real,
+        );
+
+        FixedRotateRightOperation::<AB::F>::eval(
+            builder,
+            local.xor_0.value,
+            16,
+            local.rot_0,
+            local.shard,
+            &local.channel,
+            local.is_real,
+        );
+
+        XorOperation::<AB::F>::eval(
+            builder,
+            *local.w_1.value(),
+            *local.w_5.value(),
+            local.xor_1,
+            local.shard,
+            &local.channel,
+            local.is_real,
+        );
+
+        FixedRotateRightOperation::<AB::F>::eval(
+            builder,
+            local.xor_1.value,
+            16,
+            local.rot_1,
+            local.shard,
+            &local.channel,
+            local.is_real,
+        );
+
+        XorOperation::<AB::F>::eval(
+            builder,
+            *local.w_2.value(),
+            *local.w_6.value(),
+            local.xor_2,
+            local.shard,
+            &local.channel,
+            local.is_real,
+        );
+
+        FixedRotateRightOperation::<AB::F>::eval(
+            builder,
+            local.xor_2.value,
+            16,
+            local.rot_2,
+            local.shard,
+            &local.channel,
+            local.is_real,
+        );
+
+        XorOperation::<AB::F>::eval(
+            builder,
+            *local.w_3.value(),
+            *local.w_7.value(),
+            local.xor_3,
+            local.shard,
+            &local.channel,
+            local.is_real,
+        );
+
+        FixedRotateRightOperation::<AB::F>::eval(
+            builder,
+            local.xor_3.value,
+            16,
+            local.rot_3,
+            local.shard,
+            &local.channel,
+            local.is_real,
+        );
+
+        // Write w[16]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(64),
+            &local.w_16,
+            local.is_real,
+        );
+
+        // Write w[17]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(68),
+            &local.w_17,
+            local.is_real,
+        );
+
+        // Write w[18]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(72),
+            &local.w_18,
+            local.is_real,
+        );
+
+        // Write w[19]
+        builder.eval_memory_access(
+            local.shard,
+            local.channel,
+            local.clk + (local.i - i_start),
+            local.w_ptr + AB::F::from_canonical_u32(76),
+            &local.w_19,
+            local.is_real,
+        );
+
+        builder.assert_word_eq(*local.w_16.value(), local.rot_0.value);
+        builder.assert_word_eq(*local.w_17.value(), local.rot_1.value);
+        builder.assert_word_eq(*local.w_18.value(), local.rot_2.value);
+        builder.assert_word_eq(*local.w_19.value(), local.rot_3.value);
+
+        // Receive syscall event in first row of 48-cycle.
+        builder.receive_syscall(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.nonce,
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_16.syscall_id()),
+            local.w_ptr,
+            AB::Expr::zero(),
+            local.cycle_48_start,
+        );
+
+        // Assert that is_real is a bool.
+        builder.assert_bool(local.is_real);
+
+        // Ensure that all rows in a 48 row cycle has the same `is_real` values.
+        builder
+            .when_transition()
+            .when_not(local.cycle_48_end)
+            .assert_eq(local.is_real, next.is_real);
+
+        // Assert that the table ends in nonreal columns. Since each extend ecall is 48 cycles and
+        // the table is padded to a power of 2, the last row of the table should always be padding.
+        builder.when_last_row().assert_zero(local.is_real);
+    }
+}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/columns.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/columns.rs
new file mode 100644
index 000000000..06fc34153
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/xor_rotate_16/columns.rs
@@ -0,0 +1,71 @@
+use std::mem::size_of;
+
+use sphinx_derive::AlignedBorrow;
+
+use crate::{
+    memory::{MemoryReadCols, MemoryWriteCols},
+    operations::{FixedRotateRightOperation, IsZeroOperation, XorOperation},
+};
+
+pub const NUM_BLAKE2S_XOR_ROTATE_16_COLS: usize = size_of::<Blake2sXorRotate16Cols<u8>>();
+
+#[derive(AlignedBorrow, Default, Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Blake2sXorRotate16Cols<T> {
+    /// Inputs.
+    pub shard: T,
+    pub channel: T,
+    pub nonce: T,
+    pub clk: T,
+    pub w_ptr: T,
+
+    /// Control flags.
+    pub i: T,
+
+    /// g^n where g is generator with order 16 and n is the row number.
+    pub cycle_16: T,
+
+    /// Checks whether current row is start of a 16-row cycle. Bool result is stored in `result`.
+    pub cycle_16_start: IsZeroOperation<T>,
+
+    /// Checks whether current row is end of a 16-row cycle. Bool result is stored in `result`.
+    pub cycle_16_end: IsZeroOperation<T>,
+
+    /// Flags for when in the first, second, or third 16-row cycle.
+    pub cycle_48: [T; 3],
+
+    /// Whether the current row is the first of a 48-row cycle and is real.
+    pub cycle_48_start: T,
+    /// Whether the current row is the end of a 48-row cycle and is real.
+    pub cycle_48_end: T,
+
+    /// Inputs
+    pub w_0: MemoryReadCols<T>,
+    pub w_1: MemoryReadCols<T>,
+    pub w_2: MemoryReadCols<T>,
+    pub w_3: MemoryReadCols<T>,
+    pub w_4: MemoryReadCols<T>,
+    pub w_5: MemoryReadCols<T>,
+    pub w_6: MemoryReadCols<T>,
+    pub w_7: MemoryReadCols<T>,
+
+    /// Operations
+    pub xor_0: XorOperation<T>,
+    pub xor_1: XorOperation<T>,
+    pub xor_2: XorOperation<T>,
+    pub xor_3: XorOperation<T>,
+
+    pub rot_0: FixedRotateRightOperation<T>,
+    pub rot_1: FixedRotateRightOperation<T>,
+    pub rot_2: FixedRotateRightOperation<T>,
+    pub rot_3: FixedRotateRightOperation<T>,
+
+    /// Result
+    pub w_16: MemoryWriteCols<T>,
+    pub w_17: MemoryWriteCols<T>,
+    pub w_18: MemoryWriteCols<T>,
+    pub w_19: MemoryWriteCols<T>,
+
+    /// Selector.
+    pub is_real: T,
+}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/execute.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/execute.rs
new file mode 100644
index 000000000..8a890b9e6
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/xor_rotate_16/execute.rs
@@ -0,0 +1,101 @@
+use super::Blake2sXorRotate16Chip;
+use crate::{
+    runtime::Syscall,
+    syscall::precompiles::{blake2s::Blake2sXorRotate16Event, SyscallContext},
+};
+
+impl Syscall for Blake2sXorRotate16Chip {
+    fn num_extra_cycles(&self) -> u32 {
+        48
+    }
+
+    fn execute(&self, rt: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
+        let clk_init = rt.clk;
+        let w_ptr = arg1;
+        assert!(arg2 == 0, "arg2 must be 0");
+
+        let w_ptr_init = w_ptr;
+        let mut w_0_reads = Vec::new();
+        let mut w_1_reads = Vec::new();
+        let mut w_2_reads = Vec::new();
+        let mut w_3_reads = Vec::new();
+
+        let mut w_4_reads = Vec::new();
+        let mut w_5_reads = Vec::new();
+        let mut w_6_reads = Vec::new();
+        let mut w_7_reads = Vec::new();
+
+        let mut w_16_writes = Vec::new();
+        let mut w_17_writes = Vec::new();
+        let mut w_18_writes = Vec::new();
+        let mut w_19_writes = Vec::new();
+
+        for _ in 16..64 {
+            // read
+            let (record, w_0) = rt.mr(w_ptr);
+            w_0_reads.push(record);
+
+            let (record, w_1) = rt.mr(w_ptr + 4);
+            w_1_reads.push(record);
+
+            let (record, w_2) = rt.mr(w_ptr + 8);
+            w_2_reads.push(record);
+
+            let (record, w_3) = rt.mr(w_ptr + 12);
+            w_3_reads.push(record);
+
+            let (record, w_4) = rt.mr(w_ptr + 16);
+            w_4_reads.push(record);
+
+            let (record, w_5) = rt.mr(w_ptr + 20);
+            w_5_reads.push(record);
+
+            let (record, w_6) = rt.mr(w_ptr + 24);
+            w_6_reads.push(record);
+
+            let (record, w_7) = rt.mr(w_ptr + 28);
+            w_7_reads.push(record);
+
+            // compute
+            let w_16 = (w_0 ^ w_4).rotate_right(16);
+            let w_17 = (w_1 ^ w_5).rotate_right(16);
+            let w_18 = (w_2 ^ w_6).rotate_right(16);
+            let w_19 = (w_3 ^ w_7).rotate_right(16);
+
+            // write
+            w_16_writes.push(rt.mw(w_ptr + 64, w_16));
+            w_17_writes.push(rt.mw(w_ptr + 68, w_17));
+            w_18_writes.push(rt.mw(w_ptr + 72, w_18));
+            w_19_writes.push(rt.mw(w_ptr + 76, w_19));
+            rt.clk += 1;
+        }
+
+        // Push the Blake2sXorRotate16Event event.
+        let lookup_id = rt.syscall_lookup_id;
+        let shard = rt.current_shard();
+        let channel = rt.current_channel();
+        rt.record_mut()
+            .blake2s_xor_rotate_16_events
+            .push(Blake2sXorRotate16Event {
+                lookup_id,
+                shard,
+                channel,
+                clk: clk_init,
+                w_ptr: w_ptr_init,
+                w_0_reads,
+                w_1_reads,
+                w_2_reads,
+                w_3_reads,
+                w_4_reads,
+                w_5_reads,
+                w_6_reads,
+                w_7_reads,
+                w_16_writes,
+                w_17_writes,
+                w_18_writes,
+                w_19_writes,
+            });
+
+        None
+    }
+}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/flags.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/flags.rs
new file mode 100644
index 000000000..2f705b9f2
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/xor_rotate_16/flags.rs
@@ -0,0 +1,130 @@
+use core::borrow::Borrow;
+
+use p3_air::AirBuilder;
+use p3_baby_bear::BabyBear;
+use p3_field::{AbstractField, Field, PrimeField32, TwoAdicField};
+use p3_matrix::Matrix;
+
+use crate::air::BaseAirBuilder;
+use crate::operations::IsZeroOperation;
+
+use super::Blake2sXorRotate16Chip;
+use super::Blake2sXorRotate16Cols;
+
+impl<F: Field> Blake2sXorRotate16Cols<F> {
+    pub fn populate_flags(&mut self, i: usize) {
+        // The generator of the multiplicative subgroup.
+        let g = F::from_canonical_u32(BabyBear::two_adic_generator(4).as_canonical_u32());
+
+        // Populate the columns needed to keep track of cycles of 16 rows.
+        self.cycle_16 = g.exp_u64((i + 1) as u64);
+
+        // Populate the columns needed to track the start of a cycle of 16 rows.
+        self.cycle_16_start
+            .populate_from_field_element(self.cycle_16 - g);
+
+        // Populate the columns needed to track the end of a cycle of 16 rows.
+        self.cycle_16_end
+            .populate_from_field_element(self.cycle_16 - F::one());
+
+        // Populate the columns needed to keep track of cycles of 48 rows.
+        let j = 16 + (i % 48);
+        self.i = F::from_canonical_usize(j);
+        self.cycle_48[0] = F::from_bool((16..32).contains(&j));
+        self.cycle_48[1] = F::from_bool((32..48).contains(&j));
+        self.cycle_48[2] = F::from_bool((48..64).contains(&j));
+        self.cycle_48_start = self.cycle_48[0] * self.cycle_16_start.result * self.is_real;
+        self.cycle_48_end = self.cycle_48[2] * self.cycle_16_end.result * self.is_real;
+    }
+}
+
+impl Blake2sXorRotate16Chip {
+    pub fn eval_flags<AB: BaseAirBuilder>(&self, builder: &mut AB) {
+        let main = builder.main();
+        let (local, next) = (main.row_slice(0), main.row_slice(1));
+        let local: &Blake2sXorRotate16Cols<AB::Var> = (*local).borrow();
+        let next: &Blake2sXorRotate16Cols<AB::Var> = (*next).borrow();
+
+        let one = AB::Expr::from(AB::F::one());
+
+        // Generator with order 16 within BabyBear.
+        let g = AB::F::from_canonical_u32(BabyBear::two_adic_generator(4).as_canonical_u32());
+
+        // First row of the table must have g^1.
+        builder.when_first_row().assert_eq(local.cycle_16, g);
+
+        // First row of the table must have i = 16.
+        builder
+            .when_first_row()
+            .assert_eq(local.i, AB::F::from_canonical_u32(16));
+
+        // Every row's `cycle_16` must be previous multiplied by `g`.
+        builder
+            .when_transition()
+            .assert_eq(local.cycle_16 * g, next.cycle_16);
+
+        // Constrain `cycle_16_start.result` to be `cycle_16 - g == 0`.
+        IsZeroOperation::<AB::F>::eval(
+            builder,
+            local.cycle_16 - AB::Expr::from(g),
+            local.cycle_16_start,
+            one.clone(),
+        );
+
+        // Constrain `cycle_16_end.result` to be `cycle_16 - 1 == 0`. Intuitively g^16 is 1.
+        IsZeroOperation::<AB::F>::eval(
+            builder,
+            local.cycle_16 - AB::Expr::one(),
+            local.cycle_16_end,
+            one.clone(),
+        );
+
+        // Constrain `cycle_48` to be [1, 0, 0] in the first row.
+        builder
+            .when_first_row()
+            .assert_eq(local.cycle_48[0], AB::F::one());
+        builder
+            .when_first_row()
+            .assert_eq(local.cycle_48[1], AB::F::zero());
+        builder
+            .when_first_row()
+            .assert_eq(local.cycle_48[2], AB::F::zero());
+
+        // Shift the indices of `cycles_48` at the end of each 16 rows. Otherwise, keep them the same.
+        for i in 0..3 {
+            builder
+                .when_transition()
+                .when(local.cycle_16_end.result)
+                .assert_eq(local.cycle_48[i], next.cycle_48[(i + 1) % 3]);
+            builder
+                .when_transition()
+                .when(one.clone() - local.cycle_16_end.result)
+                .assert_eq(local.cycle_48[i], next.cycle_48[i]);
+            builder.assert_bool(local.cycle_48[i]);
+        }
+
+        // cycle_48_start == start of 16-cycle AND first 16-cycle within 48-cycle AND is_real.
+        builder.assert_eq(
+            local.cycle_16_start.result * local.cycle_48[0] * local.is_real,
+            local.cycle_48_start,
+        );
+
+        // cycle_48_end == end of 16-cycle AND last 16-cycle within 48-cycle AND is_real.
+        builder.assert_eq(
+            local.cycle_16_end.result * local.cycle_48[2] * local.is_real,
+            local.cycle_48_end,
+        );
+
+        // When it's the end of a 48-cycle, the next `i` must be 16.
+        builder
+            .when_transition()
+            .when(local.cycle_16_end.result * local.cycle_48[2])
+            .assert_eq(next.i, AB::F::from_canonical_u32(16));
+
+        // When it's not the end of a 48-cycle, the next `i` must be the current plus one.
+        builder
+            .when_transition()
+            .when_not(local.cycle_16_end.result * local.cycle_48[2])
+            .assert_eq(local.i + one.clone(), next.i);
+    }
+}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/mod.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/mod.rs
new file mode 100644
index 000000000..913777829
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/xor_rotate_16/mod.rs
@@ -0,0 +1,116 @@
+mod air;
+mod columns;
+mod execute;
+mod flags;
+mod trace;
+
+pub use columns::*;
+use serde::{Deserialize, Serialize};
+
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Blake2sXorRotate16Event {
+    pub lookup_id: usize,
+    pub shard: u32,
+    pub channel: u32,
+    pub clk: u32,
+    pub w_ptr: u32,
+
+    pub w_0_reads: Vec<MemoryReadRecord>,
+    pub w_1_reads: Vec<MemoryReadRecord>,
+    pub w_2_reads: Vec<MemoryReadRecord>,
+    pub w_3_reads: Vec<MemoryReadRecord>,
+    pub w_4_reads: Vec<MemoryReadRecord>,
+    pub w_5_reads: Vec<MemoryReadRecord>,
+    pub w_6_reads: Vec<MemoryReadRecord>,
+    pub w_7_reads: Vec<MemoryReadRecord>,
+
+    pub w_16_writes: Vec<MemoryWriteRecord>,
+    pub w_17_writes: Vec<MemoryWriteRecord>,
+    pub w_18_writes: Vec<MemoryWriteRecord>,
+    pub w_19_writes: Vec<MemoryWriteRecord>,
+}
+
+#[derive(Default)]
+pub struct Blake2sXorRotate16Chip;
+
+impl Blake2sXorRotate16Chip {
+    pub const fn new() -> Self {
+        Self {}
+    }
+}
+
+#[cfg(test)]
+pub mod blake2s_xor_rotate_tests {
+    use crate::utils::run_test;
+    use crate::utils::tests::BLAKE2S_XOR_RIGHT_16_ELF;
+    use crate::{
+        runtime::{Instruction, Opcode, Program, SyscallCode},
+        utils::{self, run_test_with_memory_inspection},
+    };
+
+    pub fn blake2s_xor_rotate_16_program() -> Program {
+        let w_ptr = 100u32;
+        let mut words = [0u32; 64];
+        words[0] = 0x6b08e647;
+        words[1] = 0xbb67ae85;
+        words[2] = 0x3c6ef372;
+        words[3] = 0xa54ff53a;
+
+        words[4] = 0x510e527f;
+        words[5] = 0x9b05688c;
+        words[6] = 0x1f83d9ab;
+        words[7] = 0x5be0cd19;
+
+        let mut instructions = vec![];
+        for (i, word) in words.into_iter().enumerate() {
+            instructions.extend(vec![
+                Instruction::new(Opcode::ADD, 29, 0, word, false, true),
+                Instruction::new(Opcode::ADD, 30, 0, w_ptr + (i * 4) as u32, false, true),
+                Instruction::new(Opcode::SW, 29, 30, 0, false, true),
+            ]);
+        }
+        instructions.extend(vec![
+            Instruction::new(
+                Opcode::ADD,
+                5,
+                0,
+                SyscallCode::BLAKE_2S_XOR_ROTATE_16 as u32,
+                false,
+                true,
+            ),
+            Instruction::new(Opcode::ADD, 10, 0, w_ptr, false, true),
+            Instruction::new(Opcode::ADD, 11, 0, 0, false, true),
+            Instruction::new(Opcode::ECALL, 5, 10, 11, false, false),
+        ]);
+        Program::new(instructions, 0, 0)
+    }
+
+    #[test]
+    fn test_blake2s_xor_rotate_16_prove() {
+        utils::setup_logger();
+        let program = blake2s_xor_rotate_16_program();
+        let (_, memory) = run_test_with_memory_inspection(program);
+        let mut result = vec![];
+        for i in 0..64 {
+            result.push(memory.get(&(100 + i * 4)).unwrap().value);
+        }
+        assert_eq!(
+            result,
+            vec![
+                0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
+                0x5be0cd19, 0, 0, 0, 0, 0, 0, 0, 0, 0xb4383a06, 0xc6092062, 0x2ad923ed, 0x3823feaf,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+            ]
+        );
+    }
+
+    #[test]
+    fn test_blake2s_xor_rotate_16_program() {
+        utils::setup_logger();
+        let program = Program::from(BLAKE2S_XOR_RIGHT_16_ELF);
+        run_test(program).unwrap();
+    }
+}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/trace.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/trace.rs
new file mode 100644
index 000000000..a69762463
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/xor_rotate_16/trace.rs
@@ -0,0 +1,178 @@
+use p3_field::PrimeField32;
+use p3_matrix::dense::RowMajorMatrix;
+use p3_matrix::Matrix;
+use std::borrow::BorrowMut;
+
+use super::{
+    Blake2sXorRotate16Chip, Blake2sXorRotate16Cols, Blake2sXorRotate16Event,
+    NUM_BLAKE2S_XOR_ROTATE_16_COLS,
+};
+use crate::{
+    air::{EventLens, MachineAir, WithEvents},
+    bytes::event::ByteRecord,
+    runtime::{ExecutionRecord, Program},
+};
+
+impl<'a> WithEvents<'a> for Blake2sXorRotate16Chip {
+    type Events = &'a [Blake2sXorRotate16Event];
+}
+
+impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotate16Chip {
+    type Record = ExecutionRecord;
+
+    type Program = Program;
+
+    fn name(&self) -> String {
+        "Blake2sXorRotate16".to_string()
+    }
+
+    fn generate_trace<EL: EventLens<Self>>(
+        &self,
+        input: &EL,
+        output: &mut ExecutionRecord,
+    ) -> RowMajorMatrix<F> {
+        let mut rows = Vec::new();
+
+        let mut new_byte_lookup_events = Vec::new();
+        for i in 0..input.events().len() {
+            let event = input.events()[i].clone();
+            let shard = event.shard;
+            for j in 0..48usize {
+                let mut row = [F::zero(); NUM_BLAKE2S_XOR_ROTATE_16_COLS];
+                let cols: &mut Blake2sXorRotate16Cols<F> = row.as_mut_slice().borrow_mut();
+                cols.is_real = F::one();
+                cols.populate_flags(j);
+                cols.shard = F::from_canonical_u32(event.shard);
+                cols.channel = F::from_canonical_u32(event.channel);
+                cols.clk = F::from_canonical_u32(event.clk);
+                cols.w_ptr = F::from_canonical_u32(event.w_ptr);
+
+                cols.w_0.populate(
+                    event.channel,
+                    event.w_0_reads[j],
+                    &mut new_byte_lookup_events,
+                );
+                cols.w_1.populate(
+                    event.channel,
+                    event.w_1_reads[j],
+                    &mut new_byte_lookup_events,
+                );
+                cols.w_2.populate(
+                    event.channel,
+                    event.w_2_reads[j],
+                    &mut new_byte_lookup_events,
+                );
+                cols.w_3.populate(
+                    event.channel,
+                    event.w_3_reads[j],
+                    &mut new_byte_lookup_events,
+                );
+                cols.w_4.populate(
+                    event.channel,
+                    event.w_4_reads[j],
+                    &mut new_byte_lookup_events,
+                );
+                cols.w_5.populate(
+                    event.channel,
+                    event.w_5_reads[j],
+                    &mut new_byte_lookup_events,
+                );
+                cols.w_6.populate(
+                    event.channel,
+                    event.w_6_reads[j],
+                    &mut new_byte_lookup_events,
+                );
+                cols.w_7.populate(
+                    event.channel,
+                    event.w_7_reads[j],
+                    &mut new_byte_lookup_events,
+                );
+
+                let w_0 = event.w_0_reads[j].value;
+                let w_1 = event.w_1_reads[j].value;
+                let w_2 = event.w_2_reads[j].value;
+                let w_3 = event.w_3_reads[j].value;
+                let w_4 = event.w_4_reads[j].value;
+                let w_5 = event.w_5_reads[j].value;
+                let w_6 = event.w_6_reads[j].value;
+                let w_7 = event.w_7_reads[j].value;
+
+                let xor_0 = cols.xor_0.populate(output, shard, event.channel, w_0, w_4);
+
+                cols.rot_0.populate(output, shard, event.channel, xor_0, 16);
+
+                let xor_1 = cols.xor_1.populate(output, shard, event.channel, w_1, w_5);
+
+                cols.rot_1.populate(output, shard, event.channel, xor_1, 16);
+
+                let xor_2 = cols.xor_2.populate(output, shard, event.channel, w_2, w_6);
+
+                cols.rot_2.populate(output, shard, event.channel, xor_2, 16);
+
+                let xor_3 = cols.xor_3.populate(output, shard, event.channel, w_3, w_7);
+
+                cols.rot_3.populate(output, shard, event.channel, xor_3, 16);
+
+                cols.w_16.populate(
+                    event.channel,
+                    event.w_16_writes[j],
+                    &mut new_byte_lookup_events,
+                );
+
+                cols.w_17.populate(
+                    event.channel,
+                    event.w_17_writes[j],
+                    &mut new_byte_lookup_events,
+                );
+
+                cols.w_18.populate(
+                    event.channel,
+                    event.w_18_writes[j],
+                    &mut new_byte_lookup_events,
+                );
+
+                cols.w_19.populate(
+                    event.channel,
+                    event.w_19_writes[j],
+                    &mut new_byte_lookup_events,
+                );
+
+                rows.push(row);
+            }
+        }
+
+        output.add_byte_lookup_events(new_byte_lookup_events);
+
+        let nb_rows = rows.len();
+        let mut padded_nb_rows = nb_rows.next_power_of_two();
+        if padded_nb_rows == 2 || padded_nb_rows == 1 {
+            padded_nb_rows = 4;
+        }
+        for i in nb_rows..padded_nb_rows {
+            let mut row = [F::zero(); NUM_BLAKE2S_XOR_ROTATE_16_COLS];
+            let cols: &mut Blake2sXorRotate16Cols<F> = row.as_mut_slice().borrow_mut();
+            cols.populate_flags(i);
+            rows.push(row);
+        }
+
+        // Convert the trace to a row major matrix.
+        let mut trace = RowMajorMatrix::new(
+            rows.into_iter().flatten().collect::<Vec<_>>(),
+            NUM_BLAKE2S_XOR_ROTATE_16_COLS,
+        );
+
+        // Write the nonces to the trace.
+        for i in 0..trace.height() {
+            let cols: &mut Blake2sXorRotate16Cols<F> = trace.values
+                [i * NUM_BLAKE2S_XOR_ROTATE_16_COLS..(i + 1) * NUM_BLAKE2S_XOR_ROTATE_16_COLS]
+                .borrow_mut();
+            cols.nonce = F::from_canonical_usize(i);
+        }
+
+        trace
+    }
+
+    fn included(&self, shard: &Self::Record) -> bool {
+        !shard.blake2s_xor_rotate_16_events.is_empty()
+    }
+}
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index bbaf1f342..3eb71e98c 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -124,6 +124,9 @@ pub mod tests {
     pub const BLAKE2S_XOR_RIGHT_ROTATE_ELF: &[u8] =
         include_bytes!("../../../tests/blake2s-xor-rotate-right/elf/riscv32im-succinct-zkvm-elf");
 
+    pub const BLAKE2S_XOR_RIGHT_16_ELF: &[u8] =
+        include_bytes!("../../../tests/blake2s-xor-rotate-16/elf/riscv32im-succinct-zkvm-elf");
+
     pub const PANIC_ELF: &[u8] =
         include_bytes!("../../../tests/panic/elf/riscv32im-succinct-zkvm-elf");
 }
diff --git a/tests/blake2s-xor-rotate-16/Cargo.lock b/tests/blake2s-xor-rotate-16/Cargo.lock
new file mode 100644
index 000000000..7ab25f1f3
--- /dev/null
+++ b/tests/blake2s-xor-rotate-16/Cargo.lock
@@ -0,0 +1,539 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e1496f8fb1fbf272686b8d37f523dab3e4a7443300055e74cdaa449f3114356"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2s-xor-rotate-right-test"
+version = "0.1.0"
+dependencies = [
+ "sphinx-zkvm",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest",
+ "elliptic-curve",
+ "rfc6979",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest",
+ "ff",
+ "generic-array",
+ "group",
+ "pkcs8",
+ "rand_core",
+ "sec1",
+ "subtle",
+ "tap",
+ "zeroize",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "bitvec",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.2.0-rc.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "once_cell",
+ "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "signature",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "sphinx-precompiles"
+version = "1.0.0"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "hybrid-array",
+ "k256",
+ "serde",
+]
+
+[[package]]
+name = "sphinx-zkvm"
+version = "1.0.0"
+dependencies = [
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "k256",
+ "lazy_static",
+ "libm",
+ "once_cell",
+ "rand",
+ "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
+ "sphinx-precompiles",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-xor-rotate-16/Cargo.toml b/tests/blake2s-xor-rotate-16/Cargo.toml
new file mode 100644
index 000000000..8d49fdcb8
--- /dev/null
+++ b/tests/blake2s-xor-rotate-16/Cargo.toml
@@ -0,0 +1,8 @@
+[workspace]
+[package]
+name = "blake2s-xor-rotate-right-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-xor-rotate-16/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-16/elf/riscv32im-succinct-zkvm-elf
new file mode 100755
index 0000000000000000000000000000000000000000..f01aafa22980c248238b6d8015bbc6ec5ee35854
GIT binary patch
literal 22924
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
C>XHrs

literal 0
HcmV?d00001

diff --git a/tests/blake2s-xor-rotate-16/src/main.rs b/tests/blake2s-xor-rotate-16/src/main.rs
new file mode 100644
index 000000000..d9b63a1e0
--- /dev/null
+++ b/tests/blake2s-xor-rotate-16/src/main.rs
@@ -0,0 +1,13 @@
+#![no_main]
+sphinx_zkvm::entrypoint!(main);
+
+use sphinx_zkvm::syscalls::blake2s_xor_rotate_16::syscall_blake2s_xor_rotate_16;
+
+pub fn main() {
+    let mut w = [1u32; 64];
+    for _ in 0..10000 {
+        syscall_blake2s_xor_rotate_16(w.as_mut_ptr());
+    }
+}
+
+// summary: cycles=40957, e2e=17694, khz=2.31, proofSize=2.07 MiB
diff --git a/tests/blake2s-xor-rotate-right/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-right/elf/riscv32im-succinct-zkvm-elf
index 77111e1412cde84eb8a5897002ba4d0f055cfc2d..7e5df46dc64f6bce33f7ca736d8674bb49d97f85 100755
GIT binary patch
delta 4003
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
Te-8YoWfohqf{?{PS4#f{e;sEF

delta 4062
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
WX)9xCl(tKy*j*0k3$%FGg8u@q^KGF3

diff --git a/tests/blake2s-xor-rotate-right/src/main.rs b/tests/blake2s-xor-rotate-right/src/main.rs
index 189fad18e..3d6834f01 100644
--- a/tests/blake2s-xor-rotate-right/src/main.rs
+++ b/tests/blake2s-xor-rotate-right/src/main.rs
@@ -3,11 +3,9 @@ sphinx_zkvm::entrypoint!(main);
 
 use sphinx_zkvm::syscalls::blake2s_xor_rotate_right::syscall_blake2s_xor_rotate_right;
 
-const R_1: u32 = 16;
-
 pub fn main() {
     let mut a: [u32; 4] = [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
-    let b: [u32; 5] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, R_1];
+    let b: [u32; 4] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
 
     syscall_blake2s_xor_rotate_right(a.as_mut_ptr(), b.as_ptr());
 
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_16.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_16.rs
new file mode 100644
index 000000000..112feab08
--- /dev/null
+++ b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_16.rs
@@ -0,0 +1,19 @@
+#[cfg(target_os = "zkvm")]
+use core::arch::asm;
+
+#[allow(unused_variables)]
+#[no_mangle]
+pub extern "C" fn syscall_blake2s_xor_rotate_16(w: *mut u32) {
+    #[cfg(target_os = "zkvm")]
+    unsafe {
+        asm!(
+        "ecall",
+        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_16,
+        in("a0") w,
+        in("a1") 0
+        );
+    }
+
+    #[cfg(not(target_os = "zkvm"))]
+    unreachable!()
+}
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 6d02fcc35..5ae9d19bd 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -13,6 +13,7 @@ mod unconstrained;
 #[cfg(feature = "verify")]
 mod verify;
 
+pub mod blake2s_xor_rotate_16;
 pub mod blake2s_xor_rotate_right;
 
 pub use bls12_381::*;
@@ -110,3 +111,5 @@ pub const BLS12381_G1_DOUBLE: u32 = 0x00_00_01_72;
 pub const BLS12381_G1_DECOMPRESS: u32 = 0x00_01_01_F2;
 
 pub const BLAKE_2S_XOR_ROTATE_RIGHT: u32 = 0x00_01_01_CC;
+
+pub const BLAKE_2S_XOR_ROTATE_16: u32 = 0x00_30_01_CD;
diff --git a/zkvm/precompiles/src/lib.rs b/zkvm/precompiles/src/lib.rs
index 3619e4711..c98a46cfb 100644
--- a/zkvm/precompiles/src/lib.rs
+++ b/zkvm/precompiles/src/lib.rs
@@ -48,4 +48,5 @@ extern "C" {
     pub fn syscall_bls12381_g2_add(p: *mut u32, q: *const u32);
     pub fn syscall_bls12381_g2_double(p: *mut u32);
     pub fn syscall_blake2s_xor_rotate_right(left: *mut u32, right: *const u32);
+    pub fn syscall_blake2s_xor_rotate_16(w: *mut u32);
 }

From 2745524df0ba4adca0dfca9371e6b5ac9f5bf0cd Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 16 Sep 2024 17:02:35 +0300
Subject: [PATCH 10/30] feat: Syscall for add2 computation

---
 core/src/runtime/record.rs                    |  24 +-
 core/src/runtime/syscall.rs                   |  16 +-
 core/src/stark/air.rs                         |   8 +-
 core/src/syscall/precompiles/blake2s/add_2.rs | 382 +++++++++++++
 core/src/syscall/precompiles/blake2s/mod.rs   |   8 +-
 core/src/utils/programs.rs                    |   3 +
 tests/blake2s-add2/Cargo.lock                 | 539 ++++++++++++++++++
 tests/blake2s-add2/Cargo.toml                 |   8 +
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 0 -> 25140 bytes
 tests/blake2s-add2/src/main.rs                |  13 +
 zkvm/entrypoint/src/syscalls/blake2s_add_2.rs |  19 +
 zkvm/entrypoint/src/syscalls/mod.rs           |   3 +
 12 files changed, 1017 insertions(+), 6 deletions(-)
 create mode 100644 core/src/syscall/precompiles/blake2s/add_2.rs
 create mode 100644 tests/blake2s-add2/Cargo.lock
 create mode 100644 tests/blake2s-add2/Cargo.toml
 create mode 100755 tests/blake2s-add2/elf/riscv32im-succinct-zkvm-elf
 create mode 100644 tests/blake2s-add2/src/main.rs
 create mode 100644 zkvm/entrypoint/src/syscalls/blake2s_add_2.rs

diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index 4f177f8eb..078c2cf6d 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -11,8 +11,8 @@ use crate::runtime::MemoryInitializeFinalizeEvent;
 use crate::runtime::MemoryRecordEnum;
 use crate::stark::MachineRecord;
 use crate::syscall::precompiles::blake2s::{
-    Blake2sXorRotate16Chip, Blake2sXorRotate16Event, Blake2sXorRotateRightChip,
-    Blake2sXorRotateRightEvent,
+    Blake2sAdd2Chip, Blake2sAdd2Event, Blake2sXorRotate16Chip, Blake2sXorRotate16Event,
+    Blake2sXorRotateRightChip, Blake2sXorRotateRightEvent,
 };
 use crate::syscall::precompiles::edwards::EdDecompressEvent;
 use crate::syscall::precompiles::keccak256::KeccakPermuteEvent;
@@ -131,6 +131,7 @@ pub struct ExecutionRecord {
 
     pub blake2s_xor_rotate_right_events: Vec<Blake2sXorRotateRightEvent>,
     pub blake2s_xor_rotate_16_events: Vec<Blake2sXorRotate16Event>,
+    pub blake2s_add_2_events: Vec<Blake2sAdd2Event>,
 
     pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
 
@@ -337,6 +338,12 @@ impl EventLens<Blake2sXorRotate16Chip> for ExecutionRecord {
     }
 }
 
+impl EventLens<Blake2sAdd2Chip> for ExecutionRecord {
+    fn events(&self) -> <Blake2sAdd2Chip as crate::air::WithEvents<'_>>::Events {
+        &self.blake2s_add_2_events
+    }
+}
+
 pub struct ShardingConfig {
     pub shard_size: usize,
     pub add_len: usize,
@@ -493,6 +500,11 @@ impl MachineRecord for ExecutionRecord {
             self.blake2s_xor_rotate_16_events.len(),
         );
 
+        stats.insert(
+            "blake2s_add_2_events".to_string(),
+            self.blake2s_add_2_events.len(),
+        );
+
         stats
     }
 
@@ -542,6 +554,8 @@ impl MachineRecord for ExecutionRecord {
             .append(&mut other.blake2s_xor_rotate_right_events);
         self.blake2s_xor_rotate_16_events
             .append(&mut other.blake2s_xor_rotate_16_events);
+        self.blake2s_add_2_events
+            .append(&mut other.blake2s_add_2_events);
 
         // Merge the byte lookups.
         for (shard, events_map) in take(&mut other.byte_lookups) {
@@ -881,6 +895,12 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, (i * 48) as u32);
         }
 
+        // blake2s_xor_rotate_16 events
+        first.blake2s_add_2_events = take(&mut self.blake2s_add_2_events);
+        for (i, event) in first.blake2s_add_2_events.iter().enumerate() {
+            self.nonce_lookup.insert(event.lookup_id, i as u32);
+        }
+
         // Put MemoryInit / MemoryFinalize events in the last shard.
         let last = shards.last_mut().unwrap();
         last.memory_initialize_events
diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 5127148e5..2d1c18e59 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -6,7 +6,9 @@ use strum_macros::EnumIter;
 
 use crate::runtime::{Register, Runtime};
 use crate::stark::Ed25519Parameters;
-use crate::syscall::precompiles::blake2s::{Blake2sXorRotate16Chip, Blake2sXorRotateRightChip};
+use crate::syscall::precompiles::blake2s::{
+    Blake2sAdd2Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRightChip,
+};
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::bls12_381::g2_add::Bls12381G2AffineAddChip;
 use crate::syscall::precompiles::bls12_381::g2_double::Bls12381G2AffineDoubleChip;
@@ -121,6 +123,8 @@ pub enum SyscallCode {
     BLAKE_2S_XOR_ROTATE_RIGHT = 0x00_01_01_CC,
 
     BLAKE_2S_XOR_ROTATE_16 = 0x00_30_01_CD,
+
+    BLAKE_2S_ADD_2 = 0x00_01_01_CE,
 }
 
 impl SyscallCode {
@@ -159,6 +163,7 @@ impl SyscallCode {
             0x00_00_01_81 => SyscallCode::BLS12381_G2_DOUBLE,
             0x00_01_01_CC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT,
             0x00_30_01_CD => SyscallCode::BLAKE_2S_XOR_ROTATE_16,
+            0x00_01_01_CE => SyscallCode::BLAKE_2S_ADD_2,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -407,6 +412,11 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
         Arc::new(Blake2sXorRotate16Chip::new()),
     );
 
+    syscall_map.insert(
+        SyscallCode::BLAKE_2S_ADD_2,
+        Arc::new(Blake2sAdd2Chip::new()),
+    );
+
     syscall_map
 }
 
@@ -531,6 +541,10 @@ mod tests {
                 SyscallCode::BLAKE_2S_XOR_ROTATE_16 => {
                     assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_16)
                 }
+
+                SyscallCode::BLAKE_2S_ADD_2 => {
+                    assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_ADD_2)
+                }
             }
         }
     }
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index a3e9b272c..2984f4647 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -3,7 +3,9 @@ pub use crate::air::SphinxAirBuilder;
 use crate::air::{MachineAir, SPHINX_PROOF_NUM_PV_ELTS};
 use crate::memory::{MemoryChipType, MemoryProgramChip};
 use crate::stark::Chip;
-use crate::syscall::precompiles::blake2s::{Blake2sXorRotate16Chip, Blake2sXorRotateRightChip};
+use crate::syscall::precompiles::blake2s::{
+    Blake2sAdd2Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRightChip,
+};
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::field::FieldChip;
 use crate::syscall::precompiles::quad_field::QuadFieldChip;
@@ -110,6 +112,7 @@ pub enum RiscvAir<F: PrimeField32> {
 
     Blake2sXorRotateRight(Blake2sXorRotateRightChip),
     Blake2sXorRotate16(Blake2sXorRotate16Chip),
+    Blake2sAdd2(Blake2sAdd2Chip),
 }
 
 impl<F: PrimeField32> RiscvAir<F> {
@@ -192,6 +195,9 @@ impl<F: PrimeField32> RiscvAir<F> {
         let blake_2s_xor_rotate_16 = Blake2sXorRotate16Chip::default();
         chips.push(RiscvAir::Blake2sXorRotate16(blake_2s_xor_rotate_16));
 
+        let blake2s_add_2 = Blake2sAdd2Chip::default();
+        chips.push(RiscvAir::Blake2sAdd2(blake2s_add_2));
+
         chips
     }
 }
diff --git a/core/src/syscall/precompiles/blake2s/add_2.rs b/core/src/syscall/precompiles/blake2s/add_2.rs
new file mode 100644
index 000000000..bc58eac14
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/add_2.rs
@@ -0,0 +1,382 @@
+use crate::air::Word;
+use crate::bytes::event::ByteRecord;
+use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
+use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation};
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
+use crate::stark::SphinxAirBuilder;
+use crate::syscall::precompiles::blake2s::R_1;
+use crate::utils::pad_rows;
+use crate::{
+    air::{EventLens, MachineAir, WithEvents},
+    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
+};
+use core::borrow::{Borrow, BorrowMut};
+use p3_air::{Air, AirBuilder, BaseAir};
+use p3_field::{AbstractField, PrimeField32};
+use p3_matrix::dense::RowMajorMatrix;
+use p3_matrix::Matrix;
+use serde::Deserialize;
+use serde::Serialize;
+use sphinx_derive::AlignedBorrow;
+use std::mem::size_of;
+
+#[derive(Default)]
+pub struct Blake2sAdd2Chip;
+
+impl Blake2sAdd2Chip {
+    pub fn new() -> Self {
+        Blake2sAdd2Chip
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Blake2sAdd2Event {
+    pub lookup_id: usize,
+    pub clk: u32,
+    pub shard: u32,
+    pub channel: u32,
+    pub a_ptr: u32,
+    pub b_ptr: u32,
+
+    pub a_reads_writes: Vec<MemoryWriteRecord>,
+    pub b_reads: Vec<MemoryReadRecord>,
+    pub zero_0: Vec<MemoryReadRecord>,
+    pub zero_1: Vec<MemoryReadRecord>,
+}
+
+impl Syscall for Blake2sAdd2Chip {
+    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
+        let clk_init = ctx.clk;
+        let shard = ctx.current_shard();
+        let lookup_id = ctx.syscall_lookup_id;
+        let channel = ctx.current_channel();
+
+        let a_ptr = arg1;
+        let b_ptr = arg2;
+
+        let a = ctx.slice_unsafe(a_ptr, 4);
+        let (b_reads, mut b) = ctx.mr_slice(b_ptr, 12);
+        b[4..].iter().for_each(|item| assert_eq!(*item, 0)); // expect 8 zeroes in the end of b_ptr
+        b.truncate(4);
+
+        assert_eq!(a.len(), 4);
+        assert_eq!(b.len(), 4);
+
+        let add2 = a
+            .into_iter()
+            .zip(b.into_iter())
+            .map(|(a, b)| a.wrapping_add(b))
+            .collect::<Vec<u32>>();
+
+        ctx.clk += 1;
+
+        // Write rotate_right to a_ptr.
+        let a_reads_writes = ctx.mw_slice(a_ptr, add2.as_slice());
+
+        ctx.record_mut()
+            .blake2s_add_2_events
+            .push(Blake2sAdd2Event {
+                lookup_id,
+                clk: clk_init,
+                shard,
+                channel,
+                a_ptr,
+                b_ptr,
+                a_reads_writes,
+                b_reads: b_reads[0..4].to_vec(),
+                zero_0: b_reads[4..8].to_vec(),
+                zero_1: b_reads[8..12].to_vec(),
+            });
+
+        None
+    }
+
+    fn num_extra_cycles(&self) -> u32 {
+        1
+    }
+}
+
+#[derive(Debug, Clone, AlignedBorrow)]
+#[repr(C)]
+struct Blake2sAdd2Cols<T> {
+    pub clk: T,
+    pub shard: T,
+    pub channel: T,
+    pub nonce: T,
+    pub is_real: T,
+
+    pub a_ptr: T,
+    pub b_ptr: T,
+
+    pub a: [MemoryWriteCols<T>; 4],
+    pub b: [MemoryReadCols<T>; 4],
+    pub zero_0: [MemoryReadCols<T>; 4],
+    pub zero_1: [MemoryReadCols<T>; 4],
+
+    pub add2: [Add4Operation<T>; 4],
+}
+
+impl<T: PrimeField32> BaseAir<T> for Blake2sAdd2Chip {
+    fn width(&self) -> usize {
+        size_of::<Blake2sAdd2Cols<u8>>()
+    }
+}
+
+impl<'a> WithEvents<'a> for Blake2sAdd2Chip {
+    type Events = &'a [Blake2sAdd2Event];
+}
+
+impl<F: PrimeField32> MachineAir<F> for Blake2sAdd2Chip {
+    type Record = ExecutionRecord;
+    type Program = Program;
+
+    fn name(&self) -> String {
+        "Blake2sAdd2Chip".to_string()
+    }
+
+    fn generate_trace<EL: EventLens<Self>>(
+        &self,
+        input: &EL,
+        output: &mut Self::Record,
+    ) -> RowMajorMatrix<F> {
+        let mut rows = vec![];
+        let width = <Blake2sAdd2Chip as BaseAir<F>>::width(self);
+        let mut new_byte_lookup_events = Vec::new();
+        for event in input.events() {
+            let shard = event.shard;
+            let mut row = vec![F::zero(); width];
+            let cols: &mut Blake2sAdd2Cols<F> = row.as_mut_slice().borrow_mut();
+
+            cols.clk = F::from_canonical_u32(event.clk);
+            cols.is_real = F::one();
+            cols.shard = F::from_canonical_u32(event.shard);
+            cols.channel = F::from_canonical_u32(event.channel);
+            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
+            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
+
+            for i in 0..4usize {
+                cols.zero_0[i].populate(
+                    event.channel,
+                    event.zero_0[i],
+                    &mut new_byte_lookup_events,
+                );
+                cols.zero_1[i].populate(
+                    event.channel,
+                    event.zero_1[i],
+                    &mut new_byte_lookup_events,
+                );
+
+                cols.a[i].populate(
+                    event.channel,
+                    event.a_reads_writes[i],
+                    &mut new_byte_lookup_events,
+                );
+
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+
+                let a = event.a_reads_writes[i].value;
+                let b = event.b_reads[i].value;
+
+                let add = cols.add2[i].populate(output, shard, event.channel, a, b, 0, 0);
+                assert_eq!(a + b, add);
+            }
+
+            rows.push(row);
+        }
+
+        output.add_byte_lookup_events(new_byte_lookup_events);
+
+        pad_rows(&mut rows, || {
+            let row = vec![F::zero(); width];
+
+            row
+        });
+
+        let mut trace =
+            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
+
+        // Write the nonces to the trace.
+        for i in 0..trace.height() {
+            let cols: &mut Blake2sAdd2Cols<F> =
+                trace.values[i * width..(i + 1) * width].borrow_mut();
+            cols.nonce = F::from_canonical_usize(i);
+        }
+
+        trace
+    }
+
+    fn included(&self, shard: &Self::Record) -> bool {
+        !shard.blake2s_add_2_events.is_empty()
+    }
+}
+
+impl<AB: SphinxAirBuilder> Air<AB> for Blake2sAdd2Chip
+where
+    AB::F: PrimeField32,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local = main.row_slice(0);
+        let next = main.row_slice(1);
+        let local: &Blake2sAdd2Cols<AB::Var> = (*local).borrow();
+        let next: &Blake2sAdd2Cols<AB::Var> = (*next).borrow();
+
+        // Constrain the incrementing nonce.
+        builder.when_first_row().assert_zero(local.nonce);
+        builder
+            .when_transition()
+            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
+
+        // Eval zero_0
+        for i in 4..8usize {
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.zero_0[i - 4],
+                local.is_real,
+            );
+        }
+
+        // Eval zero_1
+        for i in 8..12usize {
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.zero_1[i - 8],
+                local.is_real,
+            );
+        }
+
+        for i in 0..4usize {
+            // Eval a
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
+                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.a[i],
+                local.is_real,
+            );
+
+            // Eval b.
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
+
+            Add4Operation::<AB::F>::eval(
+                builder,
+                *local.a[i].value(),
+                *local.b[i].value(),
+                *local.zero_0[i].value(), // zero column
+                *local.zero_1[i].value(), // zero column
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add2[i],
+            );
+        }
+
+        builder.receive_syscall(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.nonce,
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_ADD_2.syscall_id()),
+            local.a_ptr,
+            local.b_ptr,
+            local.is_real,
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::runtime::{Instruction, Opcode, SyscallCode};
+    use crate::utils::tests::{BLAKE2S_ADD_2_ELF, BLAKE2S_XOR_RIGHT_ROTATE_ELF};
+    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
+    use crate::Program;
+
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 12]) -> Program {
+        let mut instructions = vec![];
+        // memory write a
+        for (index, word) in a.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                a_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // memory write b
+        for (index, word) in b.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                b_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // Syscall invocation
+        instructions.push(Instruction::new(
+            Opcode::ADD,
+            5,
+            0,
+            SyscallCode::BLAKE_2S_ADD_2 as u32,
+            false,
+            true,
+        ));
+        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
+        Program::new(instructions, 0, 0)
+    }
+
+    #[test]
+    fn test_blake2s_add_2_precompile() {
+        setup_logger();
+
+        let a_ptr = 100100100;
+        let b_ptr = 200200200;
+        let program = risc_v_program(
+            a_ptr,
+            b_ptr,
+            [200, 300, 400, 500],
+            [10, 20, 30, 40, 0, 0, 0, 0, 0, 0, 0, 0],
+        );
+
+        let (_, memory) = run_test_with_memory_inspection(program);
+        let mut result = vec![];
+        // result is 4 words, written to a_ptr
+        for i in 0..4 {
+            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
+        }
+
+        assert_eq!(result, [210, 320, 430, 540].to_vec());
+    }
+
+    #[test]
+    fn test_blake2s_add_2_program() {
+        setup_logger();
+        let program = Program::from(BLAKE2S_ADD_2_ELF);
+        run_test(program).unwrap();
+    }
+}
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 2ceaa8ac7..102babd65 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -1,5 +1,9 @@
+mod add_2;
+mod add_3;
 mod xor_rotate_16;
 
+pub use add_2::*;
+pub use add_3::*;
 pub use xor_rotate_16::*;
 
 use crate::bytes::event::ByteRecord;
@@ -280,7 +284,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::BLAKE2S_XOR_RIGHT_ROTATE_ELF;
+    use crate::utils::tests::{BLAKE2S_ADD_2_ELF, BLAKE2S_XOR_RIGHT_ROTATE_ELF};
     use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
@@ -358,7 +362,7 @@ mod tests {
     #[test]
     fn test_blake2s_xor_right_rotate_program() {
         setup_logger();
-        let program = Program::from(BLAKE2S_XOR_RIGHT_ROTATE_ELF);
+        let program = Program::from(BLAKE2S_ADD_2_ELF);
         run_test(program).unwrap();
     }
 
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index 3eb71e98c..5671f2fcc 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -127,6 +127,9 @@ pub mod tests {
     pub const BLAKE2S_XOR_RIGHT_16_ELF: &[u8] =
         include_bytes!("../../../tests/blake2s-xor-rotate-16/elf/riscv32im-succinct-zkvm-elf");
 
+    pub const BLAKE2S_ADD_2_ELF: &[u8] =
+        include_bytes!("../../../tests/blake2s-add2/elf/riscv32im-succinct-zkvm-elf");
+
     pub const PANIC_ELF: &[u8] =
         include_bytes!("../../../tests/panic/elf/riscv32im-succinct-zkvm-elf");
 }
diff --git a/tests/blake2s-add2/Cargo.lock b/tests/blake2s-add2/Cargo.lock
new file mode 100644
index 000000000..b0f99b12f
--- /dev/null
+++ b/tests/blake2s-add2/Cargo.lock
@@ -0,0 +1,539 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2s-add2"
+version = "0.1.0"
+dependencies = [
+ "sphinx-zkvm",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest",
+ "elliptic-curve",
+ "rfc6979",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest",
+ "ff",
+ "generic-array",
+ "group",
+ "pkcs8",
+ "rand_core",
+ "sec1",
+ "subtle",
+ "tap",
+ "zeroize",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "bitvec",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.2.0-rc.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "once_cell",
+ "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "signature",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "once_cell"
+version = "1.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "sphinx-precompiles"
+version = "1.0.0"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "hybrid-array",
+ "k256",
+ "serde",
+]
+
+[[package]]
+name = "sphinx-zkvm"
+version = "1.0.0"
+dependencies = [
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "k256",
+ "lazy_static",
+ "libm",
+ "once_cell",
+ "rand",
+ "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
+ "sphinx-precompiles",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-add2/Cargo.toml b/tests/blake2s-add2/Cargo.toml
new file mode 100644
index 000000000..758f44ab5
--- /dev/null
+++ b/tests/blake2s-add2/Cargo.toml
@@ -0,0 +1,8 @@
+[workspace]
+[package]
+name = "blake2s-add2"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-add2/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-add2/elf/riscv32im-succinct-zkvm-elf
new file mode 100755
index 0000000000000000000000000000000000000000..72bd6da466349987f8f21fc79afbe3761cd08c67
GIT binary patch
literal 25140
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

literal 0
HcmV?d00001

diff --git a/tests/blake2s-add2/src/main.rs b/tests/blake2s-add2/src/main.rs
new file mode 100644
index 000000000..b3bf5661e
--- /dev/null
+++ b/tests/blake2s-add2/src/main.rs
@@ -0,0 +1,13 @@
+#![no_main]
+sphinx_zkvm::entrypoint!(main);
+
+use sphinx_zkvm::syscalls::blake2s_add_2::syscall_blake2s_add_2;
+
+pub fn main() {
+    let mut a: [u32; 4] = [200, 300, 400, 500];
+    let b: [u32; 12] = [10, 20, 30, 40, 0, 0, 0, 0, 0, 0, 0, 0];
+
+    syscall_blake2s_add_2(a.as_mut_ptr(), b.as_ptr());
+
+    assert_eq!(a, [210, 320, 430, 540]);
+}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_add_2.rs b/zkvm/entrypoint/src/syscalls/blake2s_add_2.rs
new file mode 100644
index 000000000..01ffd1d5b
--- /dev/null
+++ b/zkvm/entrypoint/src/syscalls/blake2s_add_2.rs
@@ -0,0 +1,19 @@
+#[cfg(target_os = "zkvm")]
+use core::arch::asm;
+
+#[allow(unused_variables)]
+#[no_mangle]
+pub extern "C" fn syscall_blake2s_add_2(left: *mut u32, right: *const u32) {
+    #[cfg(target_os = "zkvm")]
+    unsafe {
+        asm!(
+        "ecall",
+        in("t0") crate::syscalls::BLAKE_2S_ADD_2,
+        in("a0") left,
+        in("a1") right
+        );
+    }
+
+    #[cfg(not(target_os = "zkvm"))]
+    unreachable!()
+}
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 5ae9d19bd..252f5b6e9 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -13,6 +13,7 @@ mod unconstrained;
 #[cfg(feature = "verify")]
 mod verify;
 
+pub mod blake2s_add_2;
 pub mod blake2s_xor_rotate_16;
 pub mod blake2s_xor_rotate_right;
 
@@ -113,3 +114,5 @@ pub const BLS12381_G1_DECOMPRESS: u32 = 0x00_01_01_F2;
 pub const BLAKE_2S_XOR_ROTATE_RIGHT: u32 = 0x00_01_01_CC;
 
 pub const BLAKE_2S_XOR_ROTATE_16: u32 = 0x00_30_01_CD;
+
+pub const BLAKE_2S_ADD_2: u32 = 0x00_01_01_CE;

From 856226fbb21d566424009bebc1fa253bfff5294e Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 16 Sep 2024 17:38:20 +0300
Subject: [PATCH 11/30] feat: Syscall for add3 computing

---
 core/src/runtime/record.rs                    |  26 +-
 core/src/runtime/syscall.rs                   |  14 +-
 core/src/stark/air.rs                         |   6 +-
 core/src/syscall/precompiles/blake2s/add_2.rs |  82 ++-
 core/src/syscall/precompiles/blake2s/add_3.rs | 373 ++++++++++++
 core/src/utils/programs.rs                    |   3 +
 tests/blake2s-add3/Cargo.lock                 | 539 ++++++++++++++++++
 tests/blake2s-add3/Cargo.toml                 |   8 +
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 0 -> 25156 bytes
 tests/blake2s-add3/src/main.rs                |  13 +
 zkvm/entrypoint/src/syscalls/blake2s_add_3.rs |  19 +
 zkvm/entrypoint/src/syscalls/mod.rs           |   3 +
 zkvm/precompiles/src/lib.rs                   |   2 +
 13 files changed, 1036 insertions(+), 52 deletions(-)
 create mode 100644 core/src/syscall/precompiles/blake2s/add_3.rs
 create mode 100644 tests/blake2s-add3/Cargo.lock
 create mode 100644 tests/blake2s-add3/Cargo.toml
 create mode 100755 tests/blake2s-add3/elf/riscv32im-succinct-zkvm-elf
 create mode 100644 tests/blake2s-add3/src/main.rs
 create mode 100644 zkvm/entrypoint/src/syscalls/blake2s_add_3.rs

diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index 078c2cf6d..34aa01f2d 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -11,8 +11,8 @@ use crate::runtime::MemoryInitializeFinalizeEvent;
 use crate::runtime::MemoryRecordEnum;
 use crate::stark::MachineRecord;
 use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sAdd2Event, Blake2sXorRotate16Chip, Blake2sXorRotate16Event,
-    Blake2sXorRotateRightChip, Blake2sXorRotateRightEvent,
+    Blake2sAdd2Chip, Blake2sAdd2Event, Blake2sAdd3Chip, Blake2sAdd3Event, Blake2sXorRotate16Chip,
+    Blake2sXorRotate16Event, Blake2sXorRotateRightChip, Blake2sXorRotateRightEvent,
 };
 use crate::syscall::precompiles::edwards::EdDecompressEvent;
 use crate::syscall::precompiles::keccak256::KeccakPermuteEvent;
@@ -132,6 +132,7 @@ pub struct ExecutionRecord {
     pub blake2s_xor_rotate_right_events: Vec<Blake2sXorRotateRightEvent>,
     pub blake2s_xor_rotate_16_events: Vec<Blake2sXorRotate16Event>,
     pub blake2s_add_2_events: Vec<Blake2sAdd2Event>,
+    pub blake2s_add_3_events: Vec<Blake2sAdd3Event>,
 
     pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
 
@@ -344,6 +345,12 @@ impl EventLens<Blake2sAdd2Chip> for ExecutionRecord {
     }
 }
 
+impl EventLens<Blake2sAdd3Chip> for ExecutionRecord {
+    fn events(&self) -> <Blake2sAdd3Chip as crate::air::WithEvents<'_>>::Events {
+        &self.blake2s_add_3_events
+    }
+}
+
 pub struct ShardingConfig {
     pub shard_size: usize,
     pub add_len: usize,
@@ -505,6 +512,11 @@ impl MachineRecord for ExecutionRecord {
             self.blake2s_add_2_events.len(),
         );
 
+        stats.insert(
+            "blake2s_add_3_events".to_string(),
+            self.blake2s_add_3_events.len(),
+        );
+
         stats
     }
 
@@ -556,6 +568,8 @@ impl MachineRecord for ExecutionRecord {
             .append(&mut other.blake2s_xor_rotate_16_events);
         self.blake2s_add_2_events
             .append(&mut other.blake2s_add_2_events);
+        self.blake2s_add_3_events
+            .append(&mut other.blake2s_add_3_events);
 
         // Merge the byte lookups.
         for (shard, events_map) in take(&mut other.byte_lookups) {
@@ -895,12 +909,18 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, (i * 48) as u32);
         }
 
-        // blake2s_xor_rotate_16 events
+        // blake2s_add_2 events
         first.blake2s_add_2_events = take(&mut self.blake2s_add_2_events);
         for (i, event) in first.blake2s_add_2_events.iter().enumerate() {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
+        // blake2s_add_3 events
+        first.blake2s_add_3_events = take(&mut self.blake2s_add_3_events);
+        for (i, event) in first.blake2s_add_3_events.iter().enumerate() {
+            self.nonce_lookup.insert(event.lookup_id, i as u32);
+        }
+
         // Put MemoryInit / MemoryFinalize events in the last shard.
         let last = shards.last_mut().unwrap();
         last.memory_initialize_events
diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 2d1c18e59..0a361d4f9 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -7,7 +7,7 @@ use strum_macros::EnumIter;
 use crate::runtime::{Register, Runtime};
 use crate::stark::Ed25519Parameters;
 use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRightChip,
+    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRightChip,
 };
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::bls12_381::g2_add::Bls12381G2AffineAddChip;
@@ -125,6 +125,8 @@ pub enum SyscallCode {
     BLAKE_2S_XOR_ROTATE_16 = 0x00_30_01_CD,
 
     BLAKE_2S_ADD_2 = 0x00_01_01_CE,
+
+    BLAKE_2S_ADD_3 = 0x00_01_01_CF,
 }
 
 impl SyscallCode {
@@ -164,6 +166,7 @@ impl SyscallCode {
             0x00_01_01_CC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT,
             0x00_30_01_CD => SyscallCode::BLAKE_2S_XOR_ROTATE_16,
             0x00_01_01_CE => SyscallCode::BLAKE_2S_ADD_2,
+            0x00_01_01_CF => SyscallCode::BLAKE_2S_ADD_3,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -417,6 +420,11 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
         Arc::new(Blake2sAdd2Chip::new()),
     );
 
+    syscall_map.insert(
+        SyscallCode::BLAKE_2S_ADD_3,
+        Arc::new(Blake2sAdd3Chip::new()),
+    );
+
     syscall_map
 }
 
@@ -545,6 +553,10 @@ mod tests {
                 SyscallCode::BLAKE_2S_ADD_2 => {
                     assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_ADD_2)
                 }
+
+                SyscallCode::BLAKE_2S_ADD_3 => {
+                    assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_ADD_3)
+                }
             }
         }
     }
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index 2984f4647..eb00a385d 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -4,7 +4,7 @@ use crate::air::{MachineAir, SPHINX_PROOF_NUM_PV_ELTS};
 use crate::memory::{MemoryChipType, MemoryProgramChip};
 use crate::stark::Chip;
 use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRightChip,
+    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRightChip,
 };
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::field::FieldChip;
@@ -113,6 +113,7 @@ pub enum RiscvAir<F: PrimeField32> {
     Blake2sXorRotateRight(Blake2sXorRotateRightChip),
     Blake2sXorRotate16(Blake2sXorRotate16Chip),
     Blake2sAdd2(Blake2sAdd2Chip),
+    Blake2sAdd3(Blake2sAdd3Chip),
 }
 
 impl<F: PrimeField32> RiscvAir<F> {
@@ -198,6 +199,9 @@ impl<F: PrimeField32> RiscvAir<F> {
         let blake2s_add_2 = Blake2sAdd2Chip::default();
         chips.push(RiscvAir::Blake2sAdd2(blake2s_add_2));
 
+        let blake2s_add_3 = Blake2sAdd3Chip::default();
+        chips.push(RiscvAir::Blake2sAdd3(blake2s_add_3));
+
         chips
     }
 }
diff --git a/core/src/syscall/precompiles/blake2s/add_2.rs b/core/src/syscall/precompiles/blake2s/add_2.rs
index bc58eac14..48d70b84f 100644
--- a/core/src/syscall/precompiles/blake2s/add_2.rs
+++ b/core/src/syscall/precompiles/blake2s/add_2.rs
@@ -40,8 +40,6 @@ pub struct Blake2sAdd2Event {
 
     pub a_reads_writes: Vec<MemoryWriteRecord>,
     pub b_reads: Vec<MemoryReadRecord>,
-    pub zero_0: Vec<MemoryReadRecord>,
-    pub zero_1: Vec<MemoryReadRecord>,
 }
 
 impl Syscall for Blake2sAdd2Chip {
@@ -55,17 +53,12 @@ impl Syscall for Blake2sAdd2Chip {
         let b_ptr = arg2;
 
         let a = ctx.slice_unsafe(a_ptr, 4);
-        let (b_reads, mut b) = ctx.mr_slice(b_ptr, 12);
-        b[4..].iter().for_each(|item| assert_eq!(*item, 0)); // expect 8 zeroes in the end of b_ptr
-        b.truncate(4);
-
-        assert_eq!(a.len(), 4);
-        assert_eq!(b.len(), 4);
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 12);
 
         let add2 = a
             .into_iter()
-            .zip(b.into_iter())
-            .map(|(a, b)| a.wrapping_add(b))
+            .zip(b[0..4].into_iter())
+            .map(|(a, b)| a.wrapping_add(*b))
             .collect::<Vec<u32>>();
 
         ctx.clk += 1;
@@ -83,9 +76,7 @@ impl Syscall for Blake2sAdd2Chip {
                 a_ptr,
                 b_ptr,
                 a_reads_writes,
-                b_reads: b_reads[0..4].to_vec(),
-                zero_0: b_reads[4..8].to_vec(),
-                zero_1: b_reads[8..12].to_vec(),
+                b_reads,
             });
 
         None
@@ -109,9 +100,7 @@ struct Blake2sAdd2Cols<T> {
     pub b_ptr: T,
 
     pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 4],
-    pub zero_0: [MemoryReadCols<T>; 4],
-    pub zero_1: [MemoryReadCols<T>; 4],
+    pub b: [MemoryReadCols<T>; 12],
 
     pub add2: [Add4Operation<T>; 4],
 }
@@ -155,17 +144,6 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sAdd2Chip {
             cols.b_ptr = F::from_canonical_u32(event.b_ptr);
 
             for i in 0..4usize {
-                cols.zero_0[i].populate(
-                    event.channel,
-                    event.zero_0[i],
-                    &mut new_byte_lookup_events,
-                );
-                cols.zero_1[i].populate(
-                    event.channel,
-                    event.zero_1[i],
-                    &mut new_byte_lookup_events,
-                );
-
                 cols.a[i].populate(
                     event.channel,
                     event.a_reads_writes[i],
@@ -173,6 +151,16 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sAdd2Chip {
                 );
 
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+                cols.b[i + 4].populate(
+                    event.channel,
+                    event.b_reads[i + 4],
+                    &mut new_byte_lookup_events,
+                ); // expected to be zero
+                cols.b[i + 8].populate(
+                    event.channel,
+                    event.b_reads[i + 8],
+                    &mut new_byte_lookup_events,
+                ); // expected to be zero
 
                 let a = event.a_reads_writes[i].value;
                 let b = event.b_reads[i].value;
@@ -227,48 +215,48 @@ where
             .when_transition()
             .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
 
-        // Eval zero_0
-        for i in 4..8usize {
+        for i in 0..4usize {
+            // Eval a
             builder.eval_memory_access(
                 local.shard,
                 local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.zero_0[i - 4],
+                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
+                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.a[i],
                 local.is_real,
             );
-        }
 
-        // Eval zero_1
-        for i in 8..12usize {
+            // Eval b [0..4].
             builder.eval_memory_access(
                 local.shard,
                 local.channel,
                 local.clk,
                 local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.zero_1[i - 8],
+                &local.b[i],
                 local.is_real,
             );
-        }
 
-        for i in 0..4usize {
-            // Eval a
+            // Eval b[4..8].
             builder.eval_memory_access(
                 local.shard,
                 local.channel,
-                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
-                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.a[i],
+                local.clk,
+                local.b_ptr
+                    + ((AB::F::from_canonical_u32(4) + AB::F::from_canonical_u32(i as u32))
+                        * AB::F::from_canonical_u32(4)),
+                &local.b[i + 4],
                 local.is_real,
             );
 
-            // Eval b.
+            // Eval b[8..12].
             builder.eval_memory_access(
                 local.shard,
                 local.channel,
                 local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
+                local.b_ptr
+                    + ((AB::F::from_canonical_u32(8) + AB::F::from_canonical_u32(i as u32))
+                        * AB::F::from_canonical_u32(4)),
+                &local.b[i + 8],
                 local.is_real,
             );
 
@@ -276,8 +264,8 @@ where
                 builder,
                 *local.a[i].value(),
                 *local.b[i].value(),
-                *local.zero_0[i].value(), // zero column
-                *local.zero_1[i].value(), // zero column
+                *local.b[i + 4].value(), // zero
+                *local.b[i + 8].value(), // zero
                 local.shard,
                 local.channel,
                 local.is_real,
diff --git a/core/src/syscall/precompiles/blake2s/add_3.rs b/core/src/syscall/precompiles/blake2s/add_3.rs
new file mode 100644
index 000000000..5fcf9737a
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/add_3.rs
@@ -0,0 +1,373 @@
+use crate::air::Word;
+use crate::bytes::event::ByteRecord;
+use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
+use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation};
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
+use crate::stark::SphinxAirBuilder;
+use crate::syscall::precompiles::blake2s::R_1;
+use crate::utils::pad_rows;
+use crate::{
+    air::{EventLens, MachineAir, WithEvents},
+    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
+};
+use core::borrow::{Borrow, BorrowMut};
+use p3_air::{Air, AirBuilder, BaseAir};
+use p3_field::{AbstractField, PrimeField32};
+use p3_matrix::dense::RowMajorMatrix;
+use p3_matrix::Matrix;
+use serde::Deserialize;
+use serde::Serialize;
+use sphinx_derive::AlignedBorrow;
+use std::mem::size_of;
+
+#[derive(Default)]
+pub struct Blake2sAdd3Chip;
+
+impl Blake2sAdd3Chip {
+    pub fn new() -> Self {
+        Blake2sAdd3Chip
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Blake2sAdd3Event {
+    pub lookup_id: usize,
+    pub clk: u32,
+    pub shard: u32,
+    pub channel: u32,
+    pub a_ptr: u32,
+    pub b_ptr: u32,
+
+    pub a_reads_writes: Vec<MemoryWriteRecord>,
+    pub b_reads: Vec<MemoryReadRecord>,
+}
+
+impl Syscall for Blake2sAdd3Chip {
+    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
+        let clk_init = ctx.clk;
+        let shard = ctx.current_shard();
+        let lookup_id = ctx.syscall_lookup_id;
+        let channel = ctx.current_channel();
+
+        let a_ptr = arg1;
+        let b_ptr = arg2;
+
+        let a = ctx.slice_unsafe(a_ptr, 4);
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 12);
+        let c = b[4..8].to_vec();
+
+        let add3 = a
+            .into_iter()
+            .zip(b[0..4].into_iter())
+            .zip(c.into_iter())
+            .map(|((a, b), c)| a.wrapping_add(*b).wrapping_add(c))
+            .collect::<Vec<u32>>();
+
+        ctx.clk += 1;
+
+        // Write rotate_right to a_ptr.
+        let a_reads_writes = ctx.mw_slice(a_ptr, add3.as_slice());
+
+        ctx.record_mut()
+            .blake2s_add_3_events
+            .push(Blake2sAdd3Event {
+                lookup_id,
+                clk: clk_init,
+                shard,
+                channel,
+                a_ptr,
+                b_ptr,
+                a_reads_writes,
+                b_reads,
+            });
+
+        None
+    }
+
+    fn num_extra_cycles(&self) -> u32 {
+        1
+    }
+}
+
+#[derive(Debug, Clone, AlignedBorrow)]
+#[repr(C)]
+struct Blake2sAdd3Cols<T> {
+    pub clk: T,
+    pub shard: T,
+    pub channel: T,
+    pub nonce: T,
+    pub is_real: T,
+
+    pub a_ptr: T,
+    pub b_ptr: T,
+
+    pub a: [MemoryWriteCols<T>; 4],
+    pub b: [MemoryReadCols<T>; 12],
+
+    pub add3: [Add4Operation<T>; 4],
+}
+
+impl<T: PrimeField32> BaseAir<T> for Blake2sAdd3Chip {
+    fn width(&self) -> usize {
+        size_of::<Blake2sAdd3Cols<u8>>()
+    }
+}
+
+impl<'a> WithEvents<'a> for Blake2sAdd3Chip {
+    type Events = &'a [Blake2sAdd3Event];
+}
+
+impl<F: PrimeField32> MachineAir<F> for Blake2sAdd3Chip {
+    type Record = ExecutionRecord;
+    type Program = Program;
+
+    fn name(&self) -> String {
+        "Blake2sAdd3Chip".to_string()
+    }
+
+    fn generate_trace<EL: EventLens<Self>>(
+        &self,
+        input: &EL,
+        output: &mut Self::Record,
+    ) -> RowMajorMatrix<F> {
+        let mut rows = vec![];
+        let width = <Blake2sAdd3Chip as BaseAir<F>>::width(self);
+        let mut new_byte_lookup_events = Vec::new();
+        for event in input.events() {
+            let shard = event.shard;
+            let mut row = vec![F::zero(); width];
+            let cols: &mut Blake2sAdd3Cols<F> = row.as_mut_slice().borrow_mut();
+
+            cols.clk = F::from_canonical_u32(event.clk);
+            cols.is_real = F::one();
+            cols.shard = F::from_canonical_u32(event.shard);
+            cols.channel = F::from_canonical_u32(event.channel);
+            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
+            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
+
+            for i in 0..4usize {
+                cols.a[i].populate(
+                    event.channel,
+                    event.a_reads_writes[i],
+                    &mut new_byte_lookup_events,
+                );
+
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+                cols.b[i + 4].populate(
+                    event.channel,
+                    event.b_reads[i + 4],
+                    &mut new_byte_lookup_events,
+                );
+                cols.b[i + 8].populate(
+                    event.channel,
+                    event.b_reads[i + 8],
+                    &mut new_byte_lookup_events,
+                );
+
+                let a = event.a_reads_writes[i].value;
+                let b = event.b_reads[i].value;
+                let c = event.b_reads[i + 4].value;
+
+                let add = cols.add3[i].populate(output, shard, event.channel, a, b, c, 0);
+                assert_eq!(a + b + c, add);
+            }
+
+            rows.push(row);
+        }
+
+        output.add_byte_lookup_events(new_byte_lookup_events);
+
+        pad_rows(&mut rows, || {
+            let row = vec![F::zero(); width];
+
+            row
+        });
+
+        let mut trace =
+            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
+
+        // Write the nonces to the trace.
+        for i in 0..trace.height() {
+            let cols: &mut Blake2sAdd3Cols<F> =
+                trace.values[i * width..(i + 1) * width].borrow_mut();
+            cols.nonce = F::from_canonical_usize(i);
+        }
+
+        trace
+    }
+
+    fn included(&self, shard: &Self::Record) -> bool {
+        !shard.blake2s_add_3_events.is_empty()
+    }
+}
+
+impl<AB: SphinxAirBuilder> Air<AB> for Blake2sAdd3Chip
+where
+    AB::F: PrimeField32,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local = main.row_slice(0);
+        let next = main.row_slice(1);
+        let local: &Blake2sAdd3Cols<AB::Var> = (*local).borrow();
+        let next: &Blake2sAdd3Cols<AB::Var> = (*next).borrow();
+
+        // Constrain the incrementing nonce.
+        builder.when_first_row().assert_zero(local.nonce);
+        builder
+            .when_transition()
+            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
+
+        for i in 0..4usize {
+            // Eval a
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
+                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.a[i],
+                local.is_real,
+            );
+
+            // Eval b[0..4].
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
+
+            // Eval b[4..8].
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr
+                    + ((AB::F::from_canonical_u32(4) + AB::F::from_canonical_u32(i as u32))
+                        * AB::F::from_canonical_u32(4)),
+                &local.b[i + 4],
+                local.is_real,
+            );
+
+            // Eval b[8..12].
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr
+                    + ((AB::F::from_canonical_u32(8) + AB::F::from_canonical_u32(i as u32))
+                        * AB::F::from_canonical_u32(4)),
+                &local.b[i + 8],
+                local.is_real,
+            );
+
+            Add4Operation::<AB::F>::eval(
+                builder,
+                *local.a[i].value(),
+                *local.b[i].value(),
+                *local.b[i + 4].value(),
+                *local.b[i + 8].value(), // zero
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add3[i],
+            );
+        }
+
+        builder.receive_syscall(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.nonce,
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_ADD_3.syscall_id()),
+            local.a_ptr,
+            local.b_ptr,
+            local.is_real,
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::runtime::{Instruction, Opcode, SyscallCode};
+    use crate::utils::tests::{BLAKE2S_ADD_2_ELF, BLAKE2S_ADD_3_ELF, BLAKE2S_XOR_RIGHT_ROTATE_ELF};
+    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
+    use crate::Program;
+
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 12]) -> Program {
+        let mut instructions = vec![];
+        // memory write a
+        for (index, word) in a.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                a_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // memory write b
+        for (index, word) in b.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                b_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // Syscall invocation
+        instructions.push(Instruction::new(
+            Opcode::ADD,
+            5,
+            0,
+            SyscallCode::BLAKE_2S_ADD_3 as u32,
+            false,
+            true,
+        ));
+        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
+        Program::new(instructions, 0, 0)
+    }
+
+    #[test]
+    fn test_blake2s_add_3_precompile() {
+        setup_logger();
+
+        let a_ptr = 100100100;
+        let b_ptr = 200200200;
+        let program = risc_v_program(
+            a_ptr,
+            b_ptr,
+            [200, 300, 400, 500],
+            [10, 20, 30, 40, 1, 2, 3, 4, 0, 0, 0, 0],
+        );
+
+        let (_, memory) = run_test_with_memory_inspection(program);
+        let mut result = vec![];
+        // result is 4 words, written to a_ptr
+        for i in 0..4 {
+            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
+        }
+
+        assert_eq!(result, [211, 322, 433, 544].to_vec());
+    }
+
+    #[test]
+    fn test_blake2s_add_3_program() {
+        setup_logger();
+        let program = Program::from(BLAKE2S_ADD_3_ELF);
+        run_test(program).unwrap();
+    }
+}
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index 5671f2fcc..f70840f37 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -130,6 +130,9 @@ pub mod tests {
     pub const BLAKE2S_ADD_2_ELF: &[u8] =
         include_bytes!("../../../tests/blake2s-add2/elf/riscv32im-succinct-zkvm-elf");
 
+    pub const BLAKE2S_ADD_3_ELF: &[u8] =
+        include_bytes!("../../../tests/blake2s-add3/elf/riscv32im-succinct-zkvm-elf");
+
     pub const PANIC_ELF: &[u8] =
         include_bytes!("../../../tests/panic/elf/riscv32im-succinct-zkvm-elf");
 }
diff --git a/tests/blake2s-add3/Cargo.lock b/tests/blake2s-add3/Cargo.lock
new file mode 100644
index 000000000..d92fcf456
--- /dev/null
+++ b/tests/blake2s-add3/Cargo.lock
@@ -0,0 +1,539 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2s-add3"
+version = "0.1.0"
+dependencies = [
+ "sphinx-zkvm",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest",
+ "elliptic-curve",
+ "rfc6979",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest",
+ "ff",
+ "generic-array",
+ "group",
+ "pkcs8",
+ "rand_core",
+ "sec1",
+ "subtle",
+ "tap",
+ "zeroize",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "bitvec",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.2.0-rc.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "once_cell",
+ "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "signature",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "once_cell"
+version = "1.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "sphinx-precompiles"
+version = "1.0.0"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "hybrid-array",
+ "k256",
+ "serde",
+]
+
+[[package]]
+name = "sphinx-zkvm"
+version = "1.0.0"
+dependencies = [
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "k256",
+ "lazy_static",
+ "libm",
+ "once_cell",
+ "rand",
+ "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
+ "sphinx-precompiles",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-add3/Cargo.toml b/tests/blake2s-add3/Cargo.toml
new file mode 100644
index 000000000..b1777b692
--- /dev/null
+++ b/tests/blake2s-add3/Cargo.toml
@@ -0,0 +1,8 @@
+[workspace]
+[package]
+name = "blake2s-add3"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-add3/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-add3/elf/riscv32im-succinct-zkvm-elf
new file mode 100755
index 0000000000000000000000000000000000000000..ceef83ebba42ef5ac943d2a8ec0830351784ae26
GIT binary patch
literal 25156
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
Avj6}9

literal 0
HcmV?d00001

diff --git a/tests/blake2s-add3/src/main.rs b/tests/blake2s-add3/src/main.rs
new file mode 100644
index 000000000..594c4e344
--- /dev/null
+++ b/tests/blake2s-add3/src/main.rs
@@ -0,0 +1,13 @@
+#![no_main]
+sphinx_zkvm::entrypoint!(main);
+
+use sphinx_zkvm::syscalls::blake2s_add_3::syscall_blake2s_add_3;
+
+pub fn main() {
+    let mut a: [u32; 4] = [200, 300, 400, 500];
+    let b: [u32; 12] = [10, 20, 30, 40, 1, 2, 3, 4, 0, 0, 0, 0];
+
+    syscall_blake2s_add_3(a.as_mut_ptr(), b.as_ptr());
+
+    assert_eq!(a, [211, 322, 433, 544]);
+}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_add_3.rs b/zkvm/entrypoint/src/syscalls/blake2s_add_3.rs
new file mode 100644
index 000000000..ad6ce95cd
--- /dev/null
+++ b/zkvm/entrypoint/src/syscalls/blake2s_add_3.rs
@@ -0,0 +1,19 @@
+#[cfg(target_os = "zkvm")]
+use core::arch::asm;
+
+#[allow(unused_variables)]
+#[no_mangle]
+pub extern "C" fn syscall_blake2s_add_3(left: *mut u32, right: *const u32) {
+    #[cfg(target_os = "zkvm")]
+    unsafe {
+        asm!(
+        "ecall",
+        in("t0") crate::syscalls::BLAKE_2S_ADD_3,
+        in("a0") left,
+        in("a1") right
+        );
+    }
+
+    #[cfg(not(target_os = "zkvm"))]
+    unreachable!()
+}
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 252f5b6e9..70b605955 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -14,6 +14,7 @@ mod unconstrained;
 mod verify;
 
 pub mod blake2s_add_2;
+pub mod blake2s_add_3;
 pub mod blake2s_xor_rotate_16;
 pub mod blake2s_xor_rotate_right;
 
@@ -116,3 +117,5 @@ pub const BLAKE_2S_XOR_ROTATE_RIGHT: u32 = 0x00_01_01_CC;
 pub const BLAKE_2S_XOR_ROTATE_16: u32 = 0x00_30_01_CD;
 
 pub const BLAKE_2S_ADD_2: u32 = 0x00_01_01_CE;
+
+pub const BLAKE_2S_ADD_3: u32 = 0x00_01_01_CF;
diff --git a/zkvm/precompiles/src/lib.rs b/zkvm/precompiles/src/lib.rs
index c98a46cfb..b0112fd9b 100644
--- a/zkvm/precompiles/src/lib.rs
+++ b/zkvm/precompiles/src/lib.rs
@@ -49,4 +49,6 @@ extern "C" {
     pub fn syscall_bls12381_g2_double(p: *mut u32);
     pub fn syscall_blake2s_xor_rotate_right(left: *mut u32, right: *const u32);
     pub fn syscall_blake2s_xor_rotate_16(w: *mut u32);
+    pub fn syscall_blake2s_add_2(left: *mut u32, right: *const u32);
+    pub fn syscall_blake2s_add_3(left: *mut u32, right: *const u32);
 }

From b41f2c82c92b51cdd68ed4660203131217628443 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 16 Sep 2024 18:18:17 +0300
Subject: [PATCH 12/30] feat: Syscalls for xor_right_rotate_{16, 12}

---
 core/src/runtime/record.rs                    |  51 +-
 core/src/runtime/syscall.rs                   |  32 +-
 core/src/stark/air.rs                         |  19 +-
 core/src/syscall/precompiles/blake2s/add_2.rs |   6 +-
 core/src/syscall/precompiles/blake2s/add_3.rs |   6 +-
 core/src/syscall/precompiles/blake2s/mod.rs   | 366 +-----------
 .../blake2s/xor_rotate_right_12.rs            | 357 ++++++++++++
 .../blake2s/xor_rotate_right_16.rs            | 357 ++++++++++++
 core/src/utils/programs.rs                    |   9 +-
 tests/blake2s-xor-rotate-right-12/Cargo.lock  | 539 ++++++++++++++++++
 .../Cargo.toml                                |   2 +-
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 0 -> 25140 bytes
 tests/blake2s-xor-rotate-right-12/src/main.rs |  13 +
 .../Cargo.lock                                |   0
 tests/blake2s-xor-rotate-right-16/Cargo.toml  |   8 +
 .../elf/riscv32im-succinct-zkvm-elf           | Bin
 .../src/main.rs                               |   6 +-
 ...ight.rs => blake2s_xor_rotate_right_12.rs} |   4 +-
 .../syscalls/blake2s_xor_rotate_right_16.rs   |  19 +
 zkvm/entrypoint/src/syscalls/mod.rs           |   7 +-
 20 files changed, 1397 insertions(+), 404 deletions(-)
 create mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_right_12.rs
 create mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_right_16.rs
 create mode 100644 tests/blake2s-xor-rotate-right-12/Cargo.lock
 rename tests/{blake2s-xor-rotate-right => blake2s-xor-rotate-right-12}/Cargo.toml (74%)
 create mode 100755 tests/blake2s-xor-rotate-right-12/elf/riscv32im-succinct-zkvm-elf
 create mode 100644 tests/blake2s-xor-rotate-right-12/src/main.rs
 rename tests/{blake2s-xor-rotate-right => blake2s-xor-rotate-right-16}/Cargo.lock (100%)
 create mode 100644 tests/blake2s-xor-rotate-right-16/Cargo.toml
 rename tests/{blake2s-xor-rotate-right => blake2s-xor-rotate-right-16}/elf/riscv32im-succinct-zkvm-elf (100%)
 rename tests/{blake2s-xor-rotate-right => blake2s-xor-rotate-right-16}/src/main.rs (73%)
 rename zkvm/entrypoint/src/syscalls/{blake2s_xor_rotate_right.rs => blake2s_xor_rotate_right_12.rs} (64%)
 create mode 100644 zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_16.rs

diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index 34aa01f2d..6e7b44e4a 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -12,7 +12,8 @@ use crate::runtime::MemoryRecordEnum;
 use crate::stark::MachineRecord;
 use crate::syscall::precompiles::blake2s::{
     Blake2sAdd2Chip, Blake2sAdd2Event, Blake2sAdd3Chip, Blake2sAdd3Event, Blake2sXorRotate16Chip,
-    Blake2sXorRotate16Event, Blake2sXorRotateRightChip, Blake2sXorRotateRightEvent,
+    Blake2sXorRotate16Event, Blake2sXorRotateRight12Chip, Blake2sXorRotateRight12Event,
+    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight16Event,
 };
 use crate::syscall::precompiles::edwards::EdDecompressEvent;
 use crate::syscall::precompiles::keccak256::KeccakPermuteEvent;
@@ -129,10 +130,12 @@ pub struct ExecutionRecord {
     pub bls12381_g2_add_events: Vec<Bls12381G2AffineAddEvent>,
     pub bls12381_g2_double_events: Vec<Bls12381G2AffineDoubleEvent>,
 
-    pub blake2s_xor_rotate_right_events: Vec<Blake2sXorRotateRightEvent>,
-    pub blake2s_xor_rotate_16_events: Vec<Blake2sXorRotate16Event>,
+    // Blake2s
+    pub blake2s_xor_rotate_right_16_events: Vec<Blake2sXorRotateRight16Event>,
+    pub blake2s_xor_rotate_16_events: Vec<Blake2sXorRotate16Event>, // based on sha-extend
     pub blake2s_add_2_events: Vec<Blake2sAdd2Event>,
     pub blake2s_add_3_events: Vec<Blake2sAdd3Event>,
+    pub blake2s_xor_rotate_right_12_events: Vec<Blake2sXorRotateRight12Event>,
 
     pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
 
@@ -327,9 +330,9 @@ impl EventLens<EdDecompressChip<Ed25519Parameters>> for ExecutionRecord {
     }
 }
 
-impl EventLens<Blake2sXorRotateRightChip> for ExecutionRecord {
-    fn events(&self) -> <Blake2sXorRotateRightChip as crate::air::WithEvents<'_>>::Events {
-        &self.blake2s_xor_rotate_right_events
+impl EventLens<Blake2sXorRotateRight16Chip> for ExecutionRecord {
+    fn events(&self) -> <Blake2sXorRotateRight16Chip as crate::air::WithEvents<'_>>::Events {
+        &self.blake2s_xor_rotate_right_16_events
     }
 }
 
@@ -351,6 +354,12 @@ impl EventLens<Blake2sAdd3Chip> for ExecutionRecord {
     }
 }
 
+impl EventLens<Blake2sXorRotateRight12Chip> for ExecutionRecord {
+    fn events(&self) -> <Blake2sXorRotateRight12Chip as crate::air::WithEvents<'_>>::Events {
+        &self.blake2s_xor_rotate_right_12_events
+    }
+}
+
 pub struct ShardingConfig {
     pub shard_size: usize,
     pub add_len: usize,
@@ -499,8 +508,8 @@ impl MachineRecord for ExecutionRecord {
             self.bls12381_g2_double_events.len(),
         );
         stats.insert(
-            "blake2s_xor_rotate_right_events".to_string(),
-            self.blake2s_xor_rotate_right_events.len(),
+            "blake2s_xor_rotate_right_16_events".to_string(),
+            self.blake2s_xor_rotate_right_16_events.len(),
         );
         stats.insert(
             "blake2s_xor_rotate_16_events".to_string(),
@@ -517,6 +526,11 @@ impl MachineRecord for ExecutionRecord {
             self.blake2s_add_3_events.len(),
         );
 
+        stats.insert(
+            "blake2s_xor_rotate_right_12_events".to_string(),
+            self.blake2s_xor_rotate_right_12_events.len(),
+        );
+
         stats
     }
 
@@ -562,14 +576,17 @@ impl MachineRecord for ExecutionRecord {
             .append(&mut other.bls12381_g2_add_events);
         self.bls12381_g2_double_events
             .append(&mut other.bls12381_g2_double_events);
-        self.blake2s_xor_rotate_right_events
-            .append(&mut other.blake2s_xor_rotate_right_events);
+
+        self.blake2s_xor_rotate_right_16_events
+            .append(&mut other.blake2s_xor_rotate_right_16_events);
         self.blake2s_xor_rotate_16_events
             .append(&mut other.blake2s_xor_rotate_16_events);
         self.blake2s_add_2_events
             .append(&mut other.blake2s_add_2_events);
         self.blake2s_add_3_events
             .append(&mut other.blake2s_add_3_events);
+        self.blake2s_xor_rotate_right_12_events
+            .append(&mut other.blake2s_xor_rotate_right_12_events);
 
         // Merge the byte lookups.
         for (shard, events_map) in take(&mut other.byte_lookups) {
@@ -897,9 +914,10 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
-        // blake2s_xor_rotate_right events
-        first.blake2s_xor_rotate_right_events = take(&mut self.blake2s_xor_rotate_right_events);
-        for (i, event) in first.blake2s_xor_rotate_right_events.iter().enumerate() {
+        // blake2s_xor_rotate_right_16 events
+        first.blake2s_xor_rotate_right_16_events =
+            take(&mut self.blake2s_xor_rotate_right_16_events);
+        for (i, event) in first.blake2s_xor_rotate_right_16_events.iter().enumerate() {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
@@ -921,6 +939,13 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
+        // blake2s_xor_rotate_right_12 events
+        first.blake2s_xor_rotate_right_12_events =
+            take(&mut self.blake2s_xor_rotate_right_12_events);
+        for (i, event) in first.blake2s_xor_rotate_right_12_events.iter().enumerate() {
+            self.nonce_lookup.insert(event.lookup_id, i as u32);
+        }
+
         // Put MemoryInit / MemoryFinalize events in the last shard.
         let last = shards.last_mut().unwrap();
         last.memory_initialize_events
diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 0a361d4f9..25b9a0849 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -7,7 +7,8 @@ use strum_macros::EnumIter;
 use crate::runtime::{Register, Runtime};
 use crate::stark::Ed25519Parameters;
 use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRightChip,
+    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRight12Chip,
+    Blake2sXorRotateRight16Chip,
 };
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::bls12_381::g2_add::Bls12381G2AffineAddChip;
@@ -120,13 +121,15 @@ pub enum SyscallCode {
     /// Executes the `HINT_READ` precompile.
     HINT_READ = 0x00_00_00_F1,
 
-    BLAKE_2S_XOR_ROTATE_RIGHT = 0x00_01_01_CC,
+    BLAKE_2S_XOR_ROTATE_RIGHT_16 = 0x00_01_01_CC,
 
-    BLAKE_2S_XOR_ROTATE_16 = 0x00_30_01_CD,
+    BLAKE_2S_XOR_ROTATE_16 = 0x00_30_01_CD, // based on sha-extend
 
     BLAKE_2S_ADD_2 = 0x00_01_01_CE,
 
     BLAKE_2S_ADD_3 = 0x00_01_01_CF,
+
+    BLAKE_2S_XOR_ROTATE_RIGHT_12 = 0x00_01_01_EA,
 }
 
 impl SyscallCode {
@@ -163,10 +166,11 @@ impl SyscallCode {
             0x00_01_01_F2 => SyscallCode::BLS12381_G1_DECOMPRESS,
             0x00_01_01_80 => SyscallCode::BLS12381_G2_ADD,
             0x00_00_01_81 => SyscallCode::BLS12381_G2_DOUBLE,
-            0x00_01_01_CC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT,
+            0x00_01_01_CC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_16,
             0x00_30_01_CD => SyscallCode::BLAKE_2S_XOR_ROTATE_16,
             0x00_01_01_CE => SyscallCode::BLAKE_2S_ADD_2,
             0x00_01_01_CF => SyscallCode::BLAKE_2S_ADD_3,
+            0x00_01_01_EA => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -406,8 +410,8 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
     );
 
     syscall_map.insert(
-        SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT,
-        Arc::new(Blake2sXorRotateRightChip::new()),
+        SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_16,
+        Arc::new(Blake2sXorRotateRight16Chip::new()),
     );
 
     syscall_map.insert(
@@ -425,6 +429,11 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
         Arc::new(Blake2sAdd3Chip::new()),
     );
 
+    syscall_map.insert(
+        SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12,
+        Arc::new(Blake2sXorRotateRight12Chip::new()),
+    );
+
     syscall_map
 }
 
@@ -539,10 +548,10 @@ mod tests {
                     assert_eq!(code as u32, sphinx_zkvm::syscalls::BLS12381_G2_DOUBLE)
                 }
 
-                SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT => {
+                SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_16 => {
                     assert_eq!(
                         code as u32,
-                        sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT
+                        sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_16
                     )
                 }
 
@@ -557,6 +566,13 @@ mod tests {
                 SyscallCode::BLAKE_2S_ADD_3 => {
                     assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_ADD_3)
                 }
+
+                SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12 => {
+                    assert_eq!(
+                        code as u32,
+                        sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_12
+                    )
+                }
             }
         }
     }
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index eb00a385d..60455c427 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -4,7 +4,8 @@ use crate::air::{MachineAir, SPHINX_PROOF_NUM_PV_ELTS};
 use crate::memory::{MemoryChipType, MemoryProgramChip};
 use crate::stark::Chip;
 use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRightChip,
+    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRight12Chip,
+    Blake2sXorRotateRight16Chip,
 };
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::field::FieldChip;
@@ -110,10 +111,11 @@ pub enum RiscvAir<F: PrimeField32> {
     /// A precompile for decompressing a point on the BLS12-381 curve.
     Bls12381G1Decompress(Bls12381G1DecompressChip),
 
-    Blake2sXorRotateRight(Blake2sXorRotateRightChip),
-    Blake2sXorRotate16(Blake2sXorRotate16Chip),
+    Blake2sXorRotateRight16(Blake2sXorRotateRight16Chip),
+    Blake2sXorRotate16(Blake2sXorRotate16Chip), // based on sha-extend
     Blake2sAdd2(Blake2sAdd2Chip),
     Blake2sAdd3(Blake2sAdd3Chip),
+    Blake2sXorRotateRight12(Blake2sXorRotateRight12Chip),
 }
 
 impl<F: PrimeField32> RiscvAir<F> {
@@ -190,8 +192,10 @@ impl<F: PrimeField32> RiscvAir<F> {
         let byte = ByteChip::default();
         chips.push(RiscvAir::ByteLookup(byte));
 
-        let blake_2s_xor_rotate_right = Blake2sXorRotateRightChip::default();
-        chips.push(RiscvAir::Blake2sXorRotateRight(blake_2s_xor_rotate_right));
+        let blake_2s_xor_rotate_right_16 = Blake2sXorRotateRight16Chip::default();
+        chips.push(RiscvAir::Blake2sXorRotateRight16(
+            blake_2s_xor_rotate_right_16,
+        ));
 
         let blake_2s_xor_rotate_16 = Blake2sXorRotate16Chip::default();
         chips.push(RiscvAir::Blake2sXorRotate16(blake_2s_xor_rotate_16));
@@ -202,6 +206,11 @@ impl<F: PrimeField32> RiscvAir<F> {
         let blake2s_add_3 = Blake2sAdd3Chip::default();
         chips.push(RiscvAir::Blake2sAdd3(blake2s_add_3));
 
+        let blake_2s_xor_rotate_right_12 = Blake2sXorRotateRight12Chip::default();
+        chips.push(RiscvAir::Blake2sXorRotateRight12(
+            blake_2s_xor_rotate_right_12,
+        ));
+
         chips
     }
 }
diff --git a/core/src/syscall/precompiles/blake2s/add_2.rs b/core/src/syscall/precompiles/blake2s/add_2.rs
index 48d70b84f..98879c26e 100644
--- a/core/src/syscall/precompiles/blake2s/add_2.rs
+++ b/core/src/syscall/precompiles/blake2s/add_2.rs
@@ -1,10 +1,8 @@
-use crate::air::Word;
 use crate::bytes::event::ByteRecord;
 use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation};
+use crate::operations::Add4Operation;
 use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
 use crate::stark::SphinxAirBuilder;
-use crate::syscall::precompiles::blake2s::R_1;
 use crate::utils::pad_rows;
 use crate::{
     air::{EventLens, MachineAir, WithEvents},
@@ -289,7 +287,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::{BLAKE2S_ADD_2_ELF, BLAKE2S_XOR_RIGHT_ROTATE_ELF};
+    use crate::utils::tests::BLAKE2S_ADD_2_ELF;
     use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
diff --git a/core/src/syscall/precompiles/blake2s/add_3.rs b/core/src/syscall/precompiles/blake2s/add_3.rs
index 5fcf9737a..28506205f 100644
--- a/core/src/syscall/precompiles/blake2s/add_3.rs
+++ b/core/src/syscall/precompiles/blake2s/add_3.rs
@@ -1,10 +1,8 @@
-use crate::air::Word;
 use crate::bytes::event::ByteRecord;
 use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation};
+use crate::operations::Add4Operation;
 use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
 use crate::stark::SphinxAirBuilder;
-use crate::syscall::precompiles::blake2s::R_1;
 use crate::utils::pad_rows;
 use crate::{
     air::{EventLens, MachineAir, WithEvents},
@@ -292,7 +290,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::{BLAKE2S_ADD_2_ELF, BLAKE2S_ADD_3_ELF, BLAKE2S_XOR_RIGHT_ROTATE_ELF};
+    use crate::utils::tests::BLAKE2S_ADD_3_ELF;
     use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 102babd65..c7fae7c72 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -1,371 +1,17 @@
 mod add_2;
 mod add_3;
-mod xor_rotate_16;
+mod xor_rotate_16; // based on sha-extend
+mod xor_rotate_right_12;
+mod xor_rotate_right_16;
 
 pub use add_2::*;
 pub use add_3::*;
-pub use xor_rotate_16::*;
-
-use crate::bytes::event::ByteRecord;
-use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::{FixedRotateRightOperation, XorOperation};
-use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
-use crate::stark::SphinxAirBuilder;
-use crate::utils::pad_rows;
-use crate::{
-    air::{EventLens, MachineAir, WithEvents},
-    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
-};
-use core::borrow::{Borrow, BorrowMut};
-use p3_air::{Air, AirBuilder, BaseAir};
-use p3_field::{AbstractField, PrimeField32};
-use p3_matrix::dense::RowMajorMatrix;
-use p3_matrix::Matrix;
-use serde::Deserialize;
-use serde::Serialize;
-use sphinx_derive::AlignedBorrow;
-use std::mem::size_of;
-
-const R_1: u32 = 16;
-//const R_2: u32 = 12;
-//const R_3: u32 = 8;
-//const R_4: u32 = 7;
-
-#[derive(Default)]
-pub struct Blake2sXorRotateRightChip;
-
-impl Blake2sXorRotateRightChip {
-    pub fn new() -> Self {
-        Blake2sXorRotateRightChip
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Blake2sXorRotateRightEvent {
-    pub lookup_id: usize,
-    pub clk: u32,
-    pub shard: u32,
-    pub channel: u32,
-    pub a_ptr: u32,
-    pub b_ptr: u32,
-    pub a_reads_writes: Vec<MemoryWriteRecord>,
-    pub b_reads: Vec<MemoryReadRecord>,
-}
-
-impl Syscall for Blake2sXorRotateRightChip {
-    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
-        let clk_init = ctx.clk;
-        let shard = ctx.current_shard();
-        let lookup_id = ctx.syscall_lookup_id;
-        let channel = ctx.current_channel();
-
-        let a_ptr = arg1;
-        let b_ptr = arg2;
-
-        let a = ctx.slice_unsafe(a_ptr, 4);
-        let (b_reads, b) = ctx.mr_slice(b_ptr, 4);
-
-        let xor = a
-            .into_iter()
-            .zip(b.into_iter())
-            .map(|(a, b)| a ^ b)
-            .collect::<Vec<u32>>();
-
-        let rotate_right = xor
-            .into_iter()
-            .map(|xor_i| xor_i.rotate_right(R_1))
-            .collect::<Vec<u32>>();
-
-        ctx.clk += 1;
-
-        // Write rotate_right to a_ptr.
-        let a_reads_writes = ctx.mw_slice(a_ptr, rotate_right.as_slice());
-
-        ctx.record_mut()
-            .blake2s_xor_rotate_right_events
-            .push(Blake2sXorRotateRightEvent {
-                lookup_id,
-                clk: clk_init,
-                shard,
-                channel,
-                a_ptr,
-                b_ptr,
-                a_reads_writes,
-                b_reads,
-            });
-
-        None
-    }
-
-    fn num_extra_cycles(&self) -> u32 {
-        1
-    }
-}
-
-#[derive(Debug, Clone, AlignedBorrow)]
-#[repr(C)]
-struct Blake2sXorRotateRightCols<T> {
-    pub clk: T,
-    pub shard: T,
-    pub channel: T,
-    pub nonce: T,
-    pub is_real: T,
-
-    pub a_ptr: T,
-    pub b_ptr: T,
-
-    pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 4],
-
-    pub xor: [XorOperation<T>; 4],
-    pub rotate_right: [FixedRotateRightOperation<T>; 4],
-}
-
-impl<T: PrimeField32> BaseAir<T> for Blake2sXorRotateRightChip {
-    fn width(&self) -> usize {
-        size_of::<Blake2sXorRotateRightCols<u8>>()
-    }
-}
-
-impl<'a> WithEvents<'a> for Blake2sXorRotateRightChip {
-    type Events = &'a [Blake2sXorRotateRightEvent];
-}
-
-impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRightChip {
-    type Record = ExecutionRecord;
-    type Program = Program;
-
-    fn name(&self) -> String {
-        "Blake2sXorRotateRightChip".to_string()
-    }
-
-    fn generate_trace<EL: EventLens<Self>>(
-        &self,
-        input: &EL,
-        output: &mut Self::Record,
-    ) -> RowMajorMatrix<F> {
-        let mut rows = vec![];
-        let width = <Blake2sXorRotateRightChip as BaseAir<F>>::width(self);
-        let mut new_byte_lookup_events = Vec::new();
-        for event in input.events() {
-            let shard = event.shard;
-            let mut row = vec![F::zero(); width];
-            let cols: &mut Blake2sXorRotateRightCols<F> = row.as_mut_slice().borrow_mut();
-
-            cols.clk = F::from_canonical_u32(event.clk);
-            cols.is_real = F::one();
-            cols.shard = F::from_canonical_u32(event.shard);
-            cols.channel = F::from_canonical_u32(event.channel);
-            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
-            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
-
-            for i in 0..4usize {
-                cols.a[i].populate(
-                    event.channel,
-                    event.a_reads_writes[i],
-                    &mut new_byte_lookup_events,
-                );
-
-                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
-
-                let a = event.a_reads_writes[i].value;
-                let b = event.b_reads[i].value;
-                let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
-                assert_eq!(a ^ b, xor);
-
-                let rotate_right =
-                    cols.rotate_right[i].populate(output, shard, event.channel, xor, R_1 as usize);
-                assert_eq!(xor.rotate_right(R_1), rotate_right);
-            }
-
-            rows.push(row);
-        }
-
-        output.add_byte_lookup_events(new_byte_lookup_events);
-
-        pad_rows(&mut rows, || {
-            let row = vec![F::zero(); width];
-
-            row
-        });
-
-        let mut trace =
-            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
-
-        // Write the nonces to the trace.
-        for i in 0..trace.height() {
-            let cols: &mut Blake2sXorRotateRightCols<F> =
-                trace.values[i * width..(i + 1) * width].borrow_mut();
-            cols.nonce = F::from_canonical_usize(i);
-        }
-
-        trace
-    }
-
-    fn included(&self, shard: &Self::Record) -> bool {
-        !shard.blake2s_xor_rotate_right_events.is_empty()
-    }
-}
-
-impl<AB: SphinxAirBuilder> Air<AB> for Blake2sXorRotateRightChip
-where
-    AB::F: PrimeField32,
-{
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let local = main.row_slice(0);
-        let next = main.row_slice(1);
-        let local: &Blake2sXorRotateRightCols<AB::Var> = (*local).borrow();
-        let next: &Blake2sXorRotateRightCols<AB::Var> = (*next).borrow();
-
-        // Constrain the incrementing nonce.
-        builder.when_first_row().assert_zero(local.nonce);
-        builder
-            .when_transition()
-            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
-
-        for i in 0..4usize {
-            // Eval a
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
-                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.a[i],
-                local.is_real,
-            );
-
-            // Eval b.
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
-                local.is_real,
-            );
-
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                *local.a[i].value(),
-                *local.b[i].value(),
-                local.xor[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i].value,
-                R_1 as usize,
-                local.rotate_right[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-        }
-
-        builder.receive_syscall(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT.syscall_id()),
-            local.a_ptr,
-            local.b_ptr,
-            local.is_real,
-        )
-    }
-}
+pub use xor_rotate_16::*; // based on sha-extend
+pub use xor_rotate_right_12::*;
+pub use xor_rotate_right_16::*;
 
 #[cfg(test)]
 mod tests {
-    use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::{BLAKE2S_ADD_2_ELF, BLAKE2S_XOR_RIGHT_ROTATE_ELF};
-    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
-    use crate::Program;
-
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
-        let mut instructions = vec![];
-        // memory write a
-        for (index, word) in a.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                a_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // memory write b
-        for (index, word) in b.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                b_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // Syscall invocation
-        instructions.push(Instruction::new(
-            Opcode::ADD,
-            5,
-            0,
-            SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT as u32,
-            false,
-            true,
-        ));
-        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
-        Program::new(instructions, 0, 0)
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_right_precompile() {
-        setup_logger();
-
-        let a_ptr = 100100100;
-        let b_ptr = 200200200;
-        let program = risc_v_program(
-            a_ptr,
-            b_ptr,
-            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
-        );
-
-        let (_, memory) = run_test_with_memory_inspection(program);
-        let mut result = vec![];
-        // result is 4 words, written to a_ptr
-        for i in 0..4 {
-            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
-        }
-
-        assert_eq!(
-            result,
-            [0xb4383a06, 0xc6092062, 0x2ad923ed, 0x3823feaf].to_vec()
-        );
-    }
-
-    #[test]
-    fn test_blake2s_xor_right_rotate_program() {
-        setup_logger();
-        let program = Program::from(BLAKE2S_ADD_2_ELF);
-        run_test(program).unwrap();
-    }
-
     fn xor_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
         [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]]
     }
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_right_12.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_right_12.rs
new file mode 100644
index 000000000..b0d966ba1
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/xor_rotate_right_12.rs
@@ -0,0 +1,357 @@
+use crate::bytes::event::ByteRecord;
+use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
+use crate::operations::{FixedRotateRightOperation, XorOperation};
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
+use crate::stark::SphinxAirBuilder;
+use crate::utils::pad_rows;
+use crate::{
+    air::{EventLens, MachineAir, WithEvents},
+    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
+};
+use core::borrow::{Borrow, BorrowMut};
+use p3_air::{Air, AirBuilder, BaseAir};
+use p3_field::{AbstractField, PrimeField32};
+use p3_matrix::dense::RowMajorMatrix;
+use p3_matrix::Matrix;
+use serde::Deserialize;
+use serde::Serialize;
+use sphinx_derive::AlignedBorrow;
+use std::mem::size_of;
+
+const R_2: u32 = 12;
+
+#[derive(Default)]
+pub struct Blake2sXorRotateRight12Chip;
+
+impl Blake2sXorRotateRight12Chip {
+    pub fn new() -> Self {
+        Blake2sXorRotateRight12Chip
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Blake2sXorRotateRight12Event {
+    pub lookup_id: usize,
+    pub clk: u32,
+    pub shard: u32,
+    pub channel: u32,
+    pub a_ptr: u32,
+    pub b_ptr: u32,
+    pub a_reads_writes: Vec<MemoryWriteRecord>,
+    pub b_reads: Vec<MemoryReadRecord>,
+}
+
+impl Syscall for Blake2sXorRotateRight12Chip {
+    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
+        let clk_init = ctx.clk;
+        let shard = ctx.current_shard();
+        let lookup_id = ctx.syscall_lookup_id;
+        let channel = ctx.current_channel();
+
+        let a_ptr = arg1;
+        let b_ptr = arg2;
+
+        let a = ctx.slice_unsafe(a_ptr, 4);
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 4);
+
+        let xor = a
+            .into_iter()
+            .zip(b.into_iter())
+            .map(|(a, b)| a ^ b)
+            .collect::<Vec<u32>>();
+
+        let rotate_right = xor
+            .into_iter()
+            .map(|xor_i| xor_i.rotate_right(R_2))
+            .collect::<Vec<u32>>();
+
+        ctx.clk += 1;
+
+        // Write rotate_right to a_ptr.
+        let a_reads_writes = ctx.mw_slice(a_ptr, rotate_right.as_slice());
+
+        ctx.record_mut()
+            .blake2s_xor_rotate_right_12_events
+            .push(Blake2sXorRotateRight12Event {
+                lookup_id,
+                clk: clk_init,
+                shard,
+                channel,
+                a_ptr,
+                b_ptr,
+                a_reads_writes,
+                b_reads,
+            });
+
+        None
+    }
+
+    fn num_extra_cycles(&self) -> u32 {
+        1
+    }
+}
+
+#[derive(Debug, Clone, AlignedBorrow)]
+#[repr(C)]
+struct Blake2sXorRotateRight12Cols<T> {
+    pub clk: T,
+    pub shard: T,
+    pub channel: T,
+    pub nonce: T,
+    pub is_real: T,
+
+    pub a_ptr: T,
+    pub b_ptr: T,
+
+    pub a: [MemoryWriteCols<T>; 4],
+    pub b: [MemoryReadCols<T>; 4],
+
+    pub xor: [XorOperation<T>; 4],
+    pub rotate_right: [FixedRotateRightOperation<T>; 4],
+}
+
+impl<T: PrimeField32> BaseAir<T> for Blake2sXorRotateRight12Chip {
+    fn width(&self) -> usize {
+        size_of::<Blake2sXorRotateRight12Cols<u8>>()
+    }
+}
+
+impl<'a> WithEvents<'a> for Blake2sXorRotateRight12Chip {
+    type Events = &'a [Blake2sXorRotateRight12Event];
+}
+
+impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRight12Chip {
+    type Record = ExecutionRecord;
+    type Program = Program;
+
+    fn name(&self) -> String {
+        "Blake2sXorRotateRight12Chip".to_string()
+    }
+
+    fn generate_trace<EL: EventLens<Self>>(
+        &self,
+        input: &EL,
+        output: &mut Self::Record,
+    ) -> RowMajorMatrix<F> {
+        let mut rows = vec![];
+        let width = <Blake2sXorRotateRight12Chip as BaseAir<F>>::width(self);
+        let mut new_byte_lookup_events = Vec::new();
+        for event in input.events() {
+            let shard = event.shard;
+            let mut row = vec![F::zero(); width];
+            let cols: &mut Blake2sXorRotateRight12Cols<F> = row.as_mut_slice().borrow_mut();
+
+            cols.clk = F::from_canonical_u32(event.clk);
+            cols.is_real = F::one();
+            cols.shard = F::from_canonical_u32(event.shard);
+            cols.channel = F::from_canonical_u32(event.channel);
+            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
+            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
+
+            for i in 0..4usize {
+                cols.a[i].populate(
+                    event.channel,
+                    event.a_reads_writes[i],
+                    &mut new_byte_lookup_events,
+                );
+
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+
+                let a = event.a_reads_writes[i].value;
+                let b = event.b_reads[i].value;
+                let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
+                assert_eq!(a ^ b, xor);
+
+                let rotate_right =
+                    cols.rotate_right[i].populate(output, shard, event.channel, xor, R_2 as usize);
+                assert_eq!(xor.rotate_right(R_2), rotate_right);
+            }
+
+            rows.push(row);
+        }
+
+        output.add_byte_lookup_events(new_byte_lookup_events);
+
+        pad_rows(&mut rows, || {
+            let row = vec![F::zero(); width];
+
+            row
+        });
+
+        let mut trace =
+            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
+
+        // Write the nonces to the trace.
+        for i in 0..trace.height() {
+            let cols: &mut Blake2sXorRotateRight12Cols<F> =
+                trace.values[i * width..(i + 1) * width].borrow_mut();
+            cols.nonce = F::from_canonical_usize(i);
+        }
+
+        trace
+    }
+
+    fn included(&self, shard: &Self::Record) -> bool {
+        !shard.blake2s_xor_rotate_right_12_events.is_empty()
+    }
+}
+
+impl<AB: SphinxAirBuilder> Air<AB> for Blake2sXorRotateRight12Chip
+where
+    AB::F: PrimeField32,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local = main.row_slice(0);
+        let next = main.row_slice(1);
+        let local: &Blake2sXorRotateRight12Cols<AB::Var> = (*local).borrow();
+        let next: &Blake2sXorRotateRight12Cols<AB::Var> = (*next).borrow();
+
+        // Constrain the incrementing nonce.
+        builder.when_first_row().assert_zero(local.nonce);
+        builder
+            .when_transition()
+            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
+
+        for i in 0..4usize {
+            // Eval a
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
+                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.a[i],
+                local.is_real,
+            );
+
+            // Eval b.
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
+
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i].value(),
+                *local.b[i].value(),
+                local.xor[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i].value,
+                R_2 as usize,
+                local.rotate_right[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+        }
+
+        builder.receive_syscall(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.nonce,
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12.syscall_id()),
+            local.a_ptr,
+            local.b_ptr,
+            local.is_real,
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::runtime::{Instruction, Opcode, SyscallCode};
+    use crate::utils::tests::BLAKE2S_XOR_ROTATE_RIGHT_12_ELF;
+    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
+    use crate::Program;
+
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
+        let mut instructions = vec![];
+        // memory write a
+        for (index, word) in a.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                a_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // memory write b
+        for (index, word) in b.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                b_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // Syscall invocation
+        instructions.push(Instruction::new(
+            Opcode::ADD,
+            5,
+            0,
+            SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12 as u32,
+            false,
+            true,
+        ));
+        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
+        Program::new(instructions, 0, 0)
+    }
+
+    #[test]
+    fn test_blake2s_xor_rotate_right_12_precompile() {
+        setup_logger();
+
+        let a_ptr = 100100100;
+        let b_ptr = 200200200;
+        let program = risc_v_program(
+            a_ptr,
+            b_ptr,
+            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+        );
+
+        let (_, memory) = run_test_with_memory_inspection(program);
+        let mut result = vec![];
+        // result is 4 words, written to a_ptr
+        for i in 0..4 {
+            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
+        }
+
+        assert_eq!(
+            result,
+            [0x4383a06b, 0x6092062c, 0xad923ed2, 0x823feaf3].to_vec()
+        );
+    }
+
+    #[test]
+    fn test_blake2s_xor_rotate_right_16_program() {
+        setup_logger();
+        let program = Program::from(BLAKE2S_XOR_ROTATE_RIGHT_12_ELF);
+        run_test(program).unwrap();
+    }
+}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_right_16.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_right_16.rs
new file mode 100644
index 000000000..e836585e0
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/xor_rotate_right_16.rs
@@ -0,0 +1,357 @@
+use crate::bytes::event::ByteRecord;
+use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
+use crate::operations::{FixedRotateRightOperation, XorOperation};
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
+use crate::stark::SphinxAirBuilder;
+use crate::utils::pad_rows;
+use crate::{
+    air::{EventLens, MachineAir, WithEvents},
+    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
+};
+use core::borrow::{Borrow, BorrowMut};
+use p3_air::{Air, AirBuilder, BaseAir};
+use p3_field::{AbstractField, PrimeField32};
+use p3_matrix::dense::RowMajorMatrix;
+use p3_matrix::Matrix;
+use serde::Deserialize;
+use serde::Serialize;
+use sphinx_derive::AlignedBorrow;
+use std::mem::size_of;
+
+const R_1: u32 = 16;
+
+#[derive(Default)]
+pub struct Blake2sXorRotateRight16Chip;
+
+impl Blake2sXorRotateRight16Chip {
+    pub fn new() -> Self {
+        Blake2sXorRotateRight16Chip
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Blake2sXorRotateRight16Event {
+    pub lookup_id: usize,
+    pub clk: u32,
+    pub shard: u32,
+    pub channel: u32,
+    pub a_ptr: u32,
+    pub b_ptr: u32,
+    pub a_reads_writes: Vec<MemoryWriteRecord>,
+    pub b_reads: Vec<MemoryReadRecord>,
+}
+
+impl Syscall for Blake2sXorRotateRight16Chip {
+    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
+        let clk_init = ctx.clk;
+        let shard = ctx.current_shard();
+        let lookup_id = ctx.syscall_lookup_id;
+        let channel = ctx.current_channel();
+
+        let a_ptr = arg1;
+        let b_ptr = arg2;
+
+        let a = ctx.slice_unsafe(a_ptr, 4);
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 4);
+
+        let xor = a
+            .into_iter()
+            .zip(b.into_iter())
+            .map(|(a, b)| a ^ b)
+            .collect::<Vec<u32>>();
+
+        let rotate_right = xor
+            .into_iter()
+            .map(|xor_i| xor_i.rotate_right(R_1))
+            .collect::<Vec<u32>>();
+
+        ctx.clk += 1;
+
+        // Write rotate_right to a_ptr.
+        let a_reads_writes = ctx.mw_slice(a_ptr, rotate_right.as_slice());
+
+        ctx.record_mut()
+            .blake2s_xor_rotate_right_16_events
+            .push(Blake2sXorRotateRight16Event {
+                lookup_id,
+                clk: clk_init,
+                shard,
+                channel,
+                a_ptr,
+                b_ptr,
+                a_reads_writes,
+                b_reads,
+            });
+
+        None
+    }
+
+    fn num_extra_cycles(&self) -> u32 {
+        1
+    }
+}
+
+#[derive(Debug, Clone, AlignedBorrow)]
+#[repr(C)]
+struct Blake2sXorRotateRight16Cols<T> {
+    pub clk: T,
+    pub shard: T,
+    pub channel: T,
+    pub nonce: T,
+    pub is_real: T,
+
+    pub a_ptr: T,
+    pub b_ptr: T,
+
+    pub a: [MemoryWriteCols<T>; 4],
+    pub b: [MemoryReadCols<T>; 4],
+
+    pub xor: [XorOperation<T>; 4],
+    pub rotate_right: [FixedRotateRightOperation<T>; 4],
+}
+
+impl<T: PrimeField32> BaseAir<T> for Blake2sXorRotateRight16Chip {
+    fn width(&self) -> usize {
+        size_of::<Blake2sXorRotateRight16Cols<u8>>()
+    }
+}
+
+impl<'a> WithEvents<'a> for Blake2sXorRotateRight16Chip {
+    type Events = &'a [Blake2sXorRotateRight16Event];
+}
+
+impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRight16Chip {
+    type Record = ExecutionRecord;
+    type Program = Program;
+
+    fn name(&self) -> String {
+        "Blake2sXorRotateRight16Chip".to_string()
+    }
+
+    fn generate_trace<EL: EventLens<Self>>(
+        &self,
+        input: &EL,
+        output: &mut Self::Record,
+    ) -> RowMajorMatrix<F> {
+        let mut rows = vec![];
+        let width = <Blake2sXorRotateRight16Chip as BaseAir<F>>::width(self);
+        let mut new_byte_lookup_events = Vec::new();
+        for event in input.events() {
+            let shard = event.shard;
+            let mut row = vec![F::zero(); width];
+            let cols: &mut Blake2sXorRotateRight16Cols<F> = row.as_mut_slice().borrow_mut();
+
+            cols.clk = F::from_canonical_u32(event.clk);
+            cols.is_real = F::one();
+            cols.shard = F::from_canonical_u32(event.shard);
+            cols.channel = F::from_canonical_u32(event.channel);
+            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
+            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
+
+            for i in 0..4usize {
+                cols.a[i].populate(
+                    event.channel,
+                    event.a_reads_writes[i],
+                    &mut new_byte_lookup_events,
+                );
+
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+
+                let a = event.a_reads_writes[i].value;
+                let b = event.b_reads[i].value;
+                let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
+                assert_eq!(a ^ b, xor);
+
+                let rotate_right =
+                    cols.rotate_right[i].populate(output, shard, event.channel, xor, R_1 as usize);
+                assert_eq!(xor.rotate_right(R_1), rotate_right);
+            }
+
+            rows.push(row);
+        }
+
+        output.add_byte_lookup_events(new_byte_lookup_events);
+
+        pad_rows(&mut rows, || {
+            let row = vec![F::zero(); width];
+
+            row
+        });
+
+        let mut trace =
+            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
+
+        // Write the nonces to the trace.
+        for i in 0..trace.height() {
+            let cols: &mut Blake2sXorRotateRight16Cols<F> =
+                trace.values[i * width..(i + 1) * width].borrow_mut();
+            cols.nonce = F::from_canonical_usize(i);
+        }
+
+        trace
+    }
+
+    fn included(&self, shard: &Self::Record) -> bool {
+        !shard.blake2s_xor_rotate_right_16_events.is_empty()
+    }
+}
+
+impl<AB: SphinxAirBuilder> Air<AB> for Blake2sXorRotateRight16Chip
+where
+    AB::F: PrimeField32,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local = main.row_slice(0);
+        let next = main.row_slice(1);
+        let local: &Blake2sXorRotateRight16Cols<AB::Var> = (*local).borrow();
+        let next: &Blake2sXorRotateRight16Cols<AB::Var> = (*next).borrow();
+
+        // Constrain the incrementing nonce.
+        builder.when_first_row().assert_zero(local.nonce);
+        builder
+            .when_transition()
+            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
+
+        for i in 0..4usize {
+            // Eval a
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
+                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.a[i],
+                local.is_real,
+            );
+
+            // Eval b.
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
+
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i].value(),
+                *local.b[i].value(),
+                local.xor[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i].value,
+                R_1 as usize,
+                local.rotate_right[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+        }
+
+        builder.receive_syscall(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.nonce,
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_16.syscall_id()),
+            local.a_ptr,
+            local.b_ptr,
+            local.is_real,
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::runtime::{Instruction, Opcode, SyscallCode};
+    use crate::utils::tests::BLAKE2S_XOR_ROTATE_RIGHT_16_ELF;
+    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
+    use crate::Program;
+
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
+        let mut instructions = vec![];
+        // memory write a
+        for (index, word) in a.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                a_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // memory write b
+        for (index, word) in b.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                b_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // Syscall invocation
+        instructions.push(Instruction::new(
+            Opcode::ADD,
+            5,
+            0,
+            SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_16 as u32,
+            false,
+            true,
+        ));
+        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
+        Program::new(instructions, 0, 0)
+    }
+
+    #[test]
+    fn test_blake2s_xor_rotate_right_16_precompile() {
+        setup_logger();
+
+        let a_ptr = 100100100;
+        let b_ptr = 200200200;
+        let program = risc_v_program(
+            a_ptr,
+            b_ptr,
+            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+        );
+
+        let (_, memory) = run_test_with_memory_inspection(program);
+        let mut result = vec![];
+        // result is 4 words, written to a_ptr
+        for i in 0..4 {
+            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
+        }
+
+        assert_eq!(
+            result,
+            [0xb4383a06, 0xc6092062, 0x2ad923ed, 0x3823feaf].to_vec()
+        );
+    }
+
+    #[test]
+    fn test_blake2s_xor_rotate_right_16_program() {
+        setup_logger();
+        let program = Program::from(BLAKE2S_XOR_ROTATE_RIGHT_16_ELF);
+        run_test(program).unwrap();
+    }
+}
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index f70840f37..cfc4b3ef4 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -121,8 +121,9 @@ pub mod tests {
     pub const BLS12381_G2_DOUBLE_ELF: &[u8] =
         include_bytes!("../../../tests/bls12381-g2-double/elf/riscv32im-succinct-zkvm-elf");
 
-    pub const BLAKE2S_XOR_RIGHT_ROTATE_ELF: &[u8] =
-        include_bytes!("../../../tests/blake2s-xor-rotate-right/elf/riscv32im-succinct-zkvm-elf");
+    pub const BLAKE2S_XOR_ROTATE_RIGHT_16_ELF: &[u8] = include_bytes!(
+        "../../../tests/blake2s-xor-rotate-right-16/elf/riscv32im-succinct-zkvm-elf"
+    );
 
     pub const BLAKE2S_XOR_RIGHT_16_ELF: &[u8] =
         include_bytes!("../../../tests/blake2s-xor-rotate-16/elf/riscv32im-succinct-zkvm-elf");
@@ -133,6 +134,10 @@ pub mod tests {
     pub const BLAKE2S_ADD_3_ELF: &[u8] =
         include_bytes!("../../../tests/blake2s-add3/elf/riscv32im-succinct-zkvm-elf");
 
+    pub const BLAKE2S_XOR_ROTATE_RIGHT_12_ELF: &[u8] = include_bytes!(
+        "../../../tests/blake2s-xor-rotate-right-12/elf/riscv32im-succinct-zkvm-elf"
+    );
+
     pub const PANIC_ELF: &[u8] =
         include_bytes!("../../../tests/panic/elf/riscv32im-succinct-zkvm-elf");
 }
diff --git a/tests/blake2s-xor-rotate-right-12/Cargo.lock b/tests/blake2s-xor-rotate-right-12/Cargo.lock
new file mode 100644
index 000000000..bc27231b9
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right-12/Cargo.lock
@@ -0,0 +1,539 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2s-xor-rotate-right-12-test"
+version = "0.1.0"
+dependencies = [
+ "sphinx-zkvm",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest",
+ "elliptic-curve",
+ "rfc6979",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest",
+ "ff",
+ "generic-array",
+ "group",
+ "pkcs8",
+ "rand_core",
+ "sec1",
+ "subtle",
+ "tap",
+ "zeroize",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "bitvec",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.2.0-rc.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "once_cell",
+ "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "signature",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "once_cell"
+version = "1.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "sphinx-precompiles"
+version = "1.0.0"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "hybrid-array",
+ "k256",
+ "serde",
+]
+
+[[package]]
+name = "sphinx-zkvm"
+version = "1.0.0"
+dependencies = [
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "k256",
+ "lazy_static",
+ "libm",
+ "once_cell",
+ "rand",
+ "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
+ "sphinx-precompiles",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-xor-rotate-right/Cargo.toml b/tests/blake2s-xor-rotate-right-12/Cargo.toml
similarity index 74%
rename from tests/blake2s-xor-rotate-right/Cargo.toml
rename to tests/blake2s-xor-rotate-right-12/Cargo.toml
index 8d49fdcb8..00618a2be 100644
--- a/tests/blake2s-xor-rotate-right/Cargo.toml
+++ b/tests/blake2s-xor-rotate-right-12/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace]
 [package]
-name = "blake2s-xor-rotate-right-test"
+name = "blake2s-xor-rotate-right-12-test"
 version = "0.1.0"
 edition = "2021"
 
diff --git a/tests/blake2s-xor-rotate-right-12/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-right-12/elf/riscv32im-succinct-zkvm-elf
new file mode 100755
index 0000000000000000000000000000000000000000..5c00c03793a2dced10e8d0f6df6dd3790f7e8aec
GIT binary patch
literal 25140
zcmeHwdw3MrdH0#?u7oTE!!0(k2SyTC3rQ<!1-0FkVZo#{b_}xJBwx@nT99HPDY|e;
z9lT<-5)kUx9x&LUjzCDZQ@0IWgVNMbA1Uzy&XcA|ZH&{;wUf$RJ|}UAv4p@1`~BWC
zGt!Eioiu;-$vn?6Gw->*=RNQJoE47-S1c6-fw`B+&NKSD<0hRI;d!vaE-7L<^RU@0
zoux4qASx?DO}c-Mce-Wg9_@|Z1U3l|x~ZIH5d@c)Zk^xyGREju2=0{Y_X4(B=l2%@
zqdT?zBdZyE<WZg9)6nc?+=Lgk|J<pjN_xHW;^hEJjMe8?jF!&8E8WyT$8EIePj7#s
zz@I4aCkp(D0)L{w|4Ir>g)v;mqReEf7+tC`>6pUIXHPRLHkoPaU{X^iv;IlyWevu8
zU4$`T>~w&hX1bbbu){2_b~DYB&pN+x<g!_DI<pfnL%@x1%~Q`h9|OGdbVes&mgjM1
z(09#XdR*-YXctP*{uJ}6rvuuCqe*LEV7%WW2%2YVRy=k}G&+tjU;9yJ<n>%O*9>}%
z14o!~5ck}k%jiom<^#TVP&K*%dmi_<aleRrX3u3K8+R`1U0BMjGwp&;9Smq*CK|KR
zrbd<GZG*u3oIqoY^m}DL|8N8}P%m3;s@Pw1Y?$V44Hh%&$P}jer?B|x)6CqbW?Jo_
zl~-ZWZ3@%yZmH9l!KMjBKWo6x;>F)#zS3S6A5sLXeJZmQ57V}(tbea}*cvEd=2j)c
z@-We?9h_-_mS)?)M9ZTCK5(<;$ztY{12dzuJj{p;GV4S;>x=-eH$8$CD`7^9igDgZ
zTB-+hV}kVj(xi2=U9hHYW6=X`$@rNeW^@cN>%nb;ws$LwK7TYBUkBKM0ras|u%1M{
z=Tzo9D+<OzMbO^dCRlsh@$D6iZr~dOOjVPhfzZF^*d?vKBw5GUr!1A`sxZR8|4HRT
zOJRapb40Y1bBu76W-nvW+3hSk^BBe-#CR(DpMpLg0NsJB+vj_UVXL`~nU8^fIUclK
zhWfN7m}^@b>b5hhc`4Co3YAlt)wUGyWej*srm?Kp6iypXZ%zl@r2_*Uge&O4KnLLp
zIxx^dxPlH0bP%pjhbf>##Otn$_9pO*<+9EQt;cC+J+d4;uvXK&SK#5rdWcuxA!0pH
zZ_Ijlu^yfq;E{{9!8$ang88K4<+R+ZWO15pQ^cqOntG-($vX=)Is*I#Syb`cd;=O<
z?Mqo_3(*vGY|droUg~QKGoMmK;&-<_wbeYcoH^3k*!B7!Q--Mym8aIf)_75jCwU*_
z<3*Kq%-A}}I=8Aq)U%Np(IXhE9p!siXB0Sko?}KU@NGr8(!-1x!H%K)B<qY(-80O9
z40nPrqn-=QXeazgCRCxb-Nmns_3u>Pcjxej;Kcba*2ZzN=e(5lKc&1^cW(8s_q0GC
zv<L^MevUCsD65cW2yBne*qI2+(*)sykvqYwK_^7J5`vTic^Om$bCN1r1B!^XQVC`$
zS<o?F7S;Q_Xp=ToBYiA+d6@_Os(oHd=^$PgH4pT0d6321-ejHQ-?&V=L{mM?%v5A+
z17zIGr2hAh3|roM1^E5$_v#}9xQy*XqCOzkUSDh=V4m(0{b3#B1wTzVTPofaFWbXt
zzJbrW_!AHGP`$Po>M`#g#A7J`8s>J{$eX~7`7O}jPcUQl48dw8+QbBD4(v|X5+T~1
z;BBo~aH^()E^-#ys?g`CFYjlavcQbo8G@#ifo^@w>HABXvK;XJz$X>n`$bLJehqlw
z3tHN%*XXDBucTlLGbbsclv4&>1iW&BDL9pLoCqIH##$;et(hQYw+PYfGRy&XOAxrs
z;F%=dXk_naoMwvhA>l{wmZE&XpPs~^rnJ!da#^zH63IZ@VbDqRpYlGeDb1C}Otd?^
z?q4*e{4DQpp!N<;$?^042JY?Bl&+P=Y}6^w{G6r?%rfTUy;=FDrX;o*^YMNvdYh&k
ze#Xed`-z`_K~r}B)X?{fennuG*mbK-vofI(>*(P3A;C12346{ZlUTbg<}|F6-X{S!
znby~sDTq!x(OLiB?g`L3_dbR?e4XuiCoU2G8u*29H|7e!jrc~15dOw&d~=!vKcfDe
z_52WhBq2M%0d$U$jHnKuu}diX2xYR7-6Df8WJ8~!7<mPfF~3YQ=6+5xW``sr_bZYn
z6W;(&6*hl<ANtA%5A})Bxw2qn3w&&%iJ>17%}Dx0Y3>ri^rlaX&XJikrxiF}N@|nK
znO0uTEEzU^`*Nn;{CQ^WNEftmS<Ih<wHy~4mb%j*e=3XS3gDYQA=>q7GTMEV^R0Qa
zGDYf22hZ<kQsRfi!=lu+19<Hhqg^|aQr8cYW-D~TGhsoST+DpR3*fsT?0>TW*&&(d
zdc)NdM)o1j&(W@QwEfKQ*LF7Af;Z5P(O7YeC3QjWx`Uu^3p>M9W=@13vVA+#($g<v
zo?`#R^bdf8N6L8x{vPxd=wf{eZPOMC(p(ud8UT%oL8D?$BQ5<iOv+6kOOKo%j?!Zy
z>AW=5Sw1@EG)30ZXv`g~f8s*utR>8R?;y=xwq)dL==-Z3psmcTT}3P|?@pmL)~b66
z8=*Jx3wRB78Bf?Qy-$XG%8*YP@+n8>^hwg(7AZQnOp@jaQgmLQ2!2wCr$Gm-T}<G9
z4fsuKQ<?1>Fa8<oaG8Ye5}~``L(Tw?f#<TzBx5FcP7g^&-dEs{wg@N}AdiBPdq~h)
zVN+$?+tFV-?lkz;5u(AXg7wH`){{PgnXMVjO8<@+-?<ZZ7i+%*x*WKht!d!hbm#`q
z%Y(MFJj2?usSJKGV6X$~6xP2>y&T`UTZn?D<}O97W4$u(J7W_1{E0~Y^*^Ir($YZ-
zs?!GDcKdQ>e(<8CHOCnEGeZid!Dq{2@r=JMGmm#o1P@FC{U$}{Er(9qE@-iFSgSP9
z1GoSmtv$`v`8vsgDPsMUaa=!u))Htffz}deErQmNw=xm57C~!40)3+M%LM6mL5SWC
znRN7tWV{MF$2c+Yl*;w0^au5Y%pUj)@=ZF2NzuPd!?>8o{Owqi7Z~AduxiPkQ^qys
z#I*jKl@H=+e_Lj4{}k5kV$zJHWlFgjB#*ou$w|MgT&_F!&N)kgkACxErk$A1tev>u
znhxIU#ayta8KAi{wlpUVI%6`%|0rp)aU%8S($(#caH~7_tzTXrw?G=z0e)wrxj!01
zFS1Gfw<@RO^5bPz+PS1ApG*2;t<3ZmD_4%C$&*;Ws9g5_*)9R&y?f2RrYZlejU(A>
zfu4K;H2Y`x0`L4n1F!o2Wgptz_6w}tRrVY*A@q2lw~6OlRnQOeNIcI5#b`HZ06rpJ
zPWZwOa#=O^LH})&MX3`!K;@%6FvhlmpNL;X_(rt0SJ~c?a>(-aaD%)GkXHfnDnxU!
zptE8ue&#gr1wQaa%pIOmGu<;OIx7ME5bL%>-@(W7dndrRI(L&LvhiA*O!`HzB*cHQ
zL?9k(1|Lb#dC~-{{Q~&K<2Ajfv!W7Y_Wb$r{clOb(Zy4kw&lEFT|O_F=c?rB;#_7u
zTg$BT=cV}jTbNn9Qj`{#Fzwd21#9KM@-nUQyyWYzWj?bJ^pkF~q^01G+b&vCF6t5d
zZCZyROQLo^X1@L()At24{j`_#h531ptZlq79&u%+S$RRmbG%t`L5?n)!lZjJ{)G#Y
zwrNO`mZJUClY;hO53}|hW7@PTM)9GxVNmj&KE`}&PcuK()XY3Ba$9vSCi>c5Vv>sa
zdDyV|dC(7ub@OJjR}rEAnb>8bk%?OaO)b#Yd`z85c8z=r^Q*6rO~#yL-J&`k$a_2J
z|D0#oIyRLdP6zA)VjAeTNuJB-^V3>e5z{suP5Rp9GN1Y`{L~Wib)kFqidH+?Zw0>{
z5QnYrPh|0J51~C`Y^)o#$C^Qxs-m_L?LB7^L!hoRR($IRwk}0|(xukQT;^8=*nlZn
zel>}H2FLe!;3uIkU)w~Xjs+xbn!$YAL?Irn3Rqiw%=hT~O#9Mf%(vxz=F5Cv@MT^W
zwJ&7~KJ~}Ud?qv9+$m*QqL*3Qz_(tOp+&(f?@EFu;XM<)`jEl;RqrKj+C98qD=M<+
zKcMcvUruVPA7$3twJiFNi&?z(9U*@CZRUII$Ab0aWYT(j3zPma%B*+lSp5CVyv({6
z@OK_%+Uh#y`^|5J=s*4d_`Sp8j}czrEvKEv+q`eLiAubz|0(Gr{QVDrBhwmxFkaIP
z7T>ytX>o6cPpSyShpL!0REn5*Hj_F<W^KKjS&Ppnt=Afvw$cRu;ck2l^E{sPc_pF$
zS?_Rs!&%I48}n^Ei#*Rs#4UrO^@b|=+Kw`_>4+#TQ$!2AKsgTIjzqvbenvK#N9A?~
zHVgDtTt8gugiPK*H^9~~*ct{~GomNBex3%te&A-<U)-O+8NMCt{M?ujorAo_*Qbo?
z<Zk$NT>qqTUx;+P?Mw73(e59P(M@CY*RzTkmjh+mxD>t1!jg1Ff3DsIKSST7GhZ>{
zoh#x8(qUK4gM5?RAapVGm2s3}Lz<uMkHELKeZoHI>7N3}GV%{af4Po#WiR{?_~|H{
z3s?@pg5QHLYR7Skav5;Ibnc&$uZ);VH1gmlB0fN0uz4QW@BTB4c?ofe3?D~^k0Zke
zQlRe@=u`zdRgqo*O%Dd)7rx3Y=zJ%ZKrW;gwn_#~;X5FnGpCbJj5<mT`XF%?zQ)``
z4z9{agsYJUob>&&6HmauBAnsN!>7IqXSED=6@DVt(T-grcOst4ihg@LbU?al<8-)G
zquABK3FVpaiD47=%kb3&BX2)^bolBRoBQgZ9r?^eOYX~qzKGexvEwj5VsI~Pf11>_
zoJlXhXUk0hPv{QdLN;E?5#WQh0Nw}xwT$_vzWh7rsVd)6=+~16`ZUk6?eU|hneX&b
z)-!krdTHrkJaK~cwB7n|(1kDif+v_Sd>D6vAs*vvXen3B<yOj}(b&sV=Lfno;KKbX
z1%8zRA5D?w2nzU32EWOW8yV}Xk{^uc?+{->E}`Ea43ccl($snpHYA;%nrFY*GqvZZ
zR{Nf2|5?=cdcV<w4Ona2cb8dW??t}}+DeP1p8f&Fik=^@Wh&tH0Z}VI!Qz>U6o>xO
zzLhCxs}~5q@wZ9V>f7)>UeF%>&7<*etQO;sy#si^5WV*{*uh%`>+MWIx_3PC9T$@E
z%-4kIzu(HDKh6a298DVI&m=q91;JpjU!G&h{`Y=x5xHp9-13~PO@(|vI7{f63f$Uz
zmiasvMD4+;g5~MG7{|LW_8j7%$%0mnddS!HtV2B4zDy!`blGGk1>v7~KgWFD<E)b*
zU&@{b4Lz_49n9Qv3gg2E_n;g(Dae{+u;-w!;3H0kpNIbZ=npwc$)`NWB&R<M_2ccw
zSZ4&es|dz-+FPD_5%2(yja4P0#b6Ji7ablhg`S`|MdEP^^ngaWH~8#Md~(W#WBd`{
z$G-vNt7^o^?qmM7^xk&20p0^2LmwOh&hUk&lPtA3aW|Xbu06%4&?}?^MCcQ{F15=`
ziQgfI#(V)~eZa+y&m%+V<0AM+rMN#;H<9d7{ucR%tW>>&Jflpy2Cz}R1=-`e46-<)
zw;-RC^D$-~LhL`H4<@1=+UJAzy~vp@LoDQ>_zQR+Ld<v!W41#cmO<t`zz6V|hoDdT
zpjWuQyvDeFTnG3kgJw!BpY#I9WhTaSbtuN?xa0zt*)A^1WE+<N=?>&31l3Z?5Er73
zzF$QjiWM8tr>8-uPn5?nvRe>iK7kl>KlLSOY2Xd=tKgqgjA5lA-=-ulYdZ#h(=$0e
z-P+OBA<c_n-U{$I1icd^{SSSxgy#-yJzAbcd|=(w!ThmEM9U!E#lWja!1svhm2grk
zo(!J<JG3u@ubjZMMc{UC+)d1!qD<2UE{->ERi>Dmo>r_h<m&!r9P|ug%+`5RrQkUD
zcRY{A+iGfnw~yusybrXW<Wrl<;;|;7e@fFu^5@}uT<ouT`Xit6G~l}+lM!Y%Bt%nu
zdIHIUuk8ermco}5kKDw4!)YhTH_X)9kbA)1k+1DYAb#}7*u9y@R9Qn?ON}L^S$&Yz
zJwm)af&C5-<oX!)D7-9w{6QhU?H<882K{njh{f-Dh<|JM3?+R-UV(h!_=R@Ce98m8
zk9_jEqr;$;=xYZ)%aD6b?~!bLkdMVU{liCxOmDXwZ^Jl8f$z2>m<xQ_X$ittBE1@K
zdrGi&0ydQU+j!gS$PFQWn|S!Qw3gc6ATC9mMKtWsQhtRP?blWY;-VB9_dh=Gmz-uS
z0v^r!M0pMgxr^xhGQ|Ig#c%JUT&3dZ`)kH=(wrFR4O@~8n=%J>06b?hRgQMQ>e%-3
zELvBxE5sMb13+duE&^=KNKQ05r_c7s$hO2P9lm-2J|xA1u+^}`&~MjnWBWSSl@rRt
zO2Hs}JLIE5A2UmtNO($=!$XcG8eD}qCJ4AHQ|uDW*^YeL@|2vef}E~y$D?-p%q#4A
zE7mN7_Cl_1djfuhJuaXBL?xZ)UeHfxS^@MB@(#J%5pTkuf)2Kn0s%US?6Uy6iqTxq
zcGhz2cWnnBzRLXzuA9=Ko96x$vil3@+uy<$6C|#Gpt~F&=oa$vpj)`Fv*+iOqm67v
z-Uc}KLFZweyWKo`PRjhC55yv&Q(VI74w_#xH|Fw%Z8MJE!uLF&-+4ald@{L?Eq)$#
zZ2uFs!9ZS-YykH=xqgJ-2K{R(0(2{M?TEjbxS8uA<wpLdYe(2FjKOoj(Jn=>bIiT0
zF^lyA&ixbUMd<P;#4{1-LRxdo+0M%&ej}c=eJ-p+3)Z0zdZ<kJpZHv)597rV<{RiD
zA6AvRUtw0!B+OmF+K!Be^=%pT@!B8%mgd<rmHT)bwF{cZ|H}~{@92zwhmUuR`*^u`
z|IBL3eIV7x^A&e6->HK%7RG3$*c#6zT(2W%LNX&l&ctYTS&DBUyS6;)$aX($@pRB?
zI%qZB&}V!ax$;|#`DM2tSAI)ROb6YRVdDVq4rLf};_#UAU{6>lKO@^xz9Tw*$QGh6
z_JfD5Sd7mby47Rz9~&>_K(FKg7Zo@yX;G~QngwmoZsZb9BB!t$aU*iKRoD}Uf7By_
zW?RK`zUFd@4+USfBKQUnw@*gDdtVab)z33)_hir-<qx(CzAvA``-8mPda6x`zt_!t
z%2S{_^J?lj_+E#Zx$_mK9sLlpf?Pf9iG$am@Bhsav_z|9DG?Tb_cMaoaCi#jX&i9R
zveL@Njn)mEhfW3WApTGV@}15_yH6ywlWmA!k1^|Ho8Vh_0k+^M@+9qy<8gYBp8+sB
zerE3vARmssE94!NVLyBlON5TZSTqLTUm;!*!wyW~Fv0<KJg|4b(ZxIRo>snH=uF$6
zu9c?=27hj6o!<TFhIhs|?L@24=|R~ESupssm368pQ=dp5ncGNTy{GJXeZ?ak9Y{ux
zLROBQN=A=iZc{L~wQnH*gMHIIp!1nC_&&yr4#a1)-|+{`2Yi}l=ug1^o8cM3MNXx2
z?^}O3onMEnFZqM;0)Ikw%5WwD@;SQ?dRGvnS!IrHXc2n0!ax1~){nH6ZKM3zxRO~b
zvF^yh#Ty@BmK9~7nc!Qy0d!i+wAVmCs`Hvt=e%9V=8X;D4b)lLZr51}`tp7rwELNg
z?{yoQZ{0fd<J5W0sdL`0Lu(R0vk^H;)LDr<3daZX!uxs1?g!@^d{vv6uc`|DICWlg
z>YTUhSbMh#@w1y){4CXpIXK7ce$JQkeyrUwA%3bEd7Ln_%8?g^>{%;qSiAx6Pi`go
z6MW%v7DpV4yc+C?&DZujY@s6AJk84xPsO|`-;f9F7n2;=^#dsPq<r6p^3?ANl&dM_
z^(c40JNVcnFLr<QP2;D2WBf7SG=6G1#vk)d<ENHm{4w7&zFQ7o20EY1H0ent_}7lU
z%z>V9_2oR+s$WC@PK5rQ2>m+|`d5SgodEqi0s41>F*`H?dzBM3*e^@e?YTg2m=h1r
zq`avg`WboCVJTM`j)#vx$0;)rYYs=3E08TF`_hWb%)xAl>Ji+h6oU>5^oR`I4O_r{
zgTP_m_NU2yOgDF=W$?P`=r3&%{D(BVu8Mq#?MM8Rl(PeR{D<)65XY9l=EV~5U%ria
z>U)5}m*aYq{25nQ^?plJ7NH*|jOfkW-%oE^F^V~$H+QA#%|4sHm>Y6M(5J5MwBhmA
z>@uI6EocMsuy*l7$@<Sq><z+Rwx;trA_p}rb#2E!>#HK|W%$%`!B-5s5$nPkvR6f;
z`vuV&SHwt9YjSxO?R(M~S~}@xXPzT-j64B)3l{dMXum!RJxb@~qR^w#@e@hNJGTSY
z9*>}rJW|ZC_9T2a=vH;<7=1;3TO#GCTwcPyS}cvvRU3B;v%Wq~?$7$dMQ2T6Pq3Dw
z>$8{OhBrro{hug-uVDWtB9}7}e)a@uZp#GZawbUggbC4keOcf?jr;)HZ**;XV(zF-
z4^SLn@3r%sf&yH1cYlw|lx_Qa|Junlyyn&iPa_t8g85sqJ~GxICQI;#Wt!KXpV;RH
zjG2H_o<To2>_3(EWt?YNYaBc{dY+*h@9ueq=jq)!&+u)$yXP5R#JhW*;UDnso@eMd
zD2|+GIB*c_DT~HIS#<3FudrTD{)E+YU#NLtyru@2S=9}CLdN6-BRK7U^L=nb<+)W}
z*Y!PfV$6Kp&b2|V9G@r_NTJ`aDbI&91hl8m{e1EV?Q;yQ7_=I*Z_MMBoFM46gmQSY
zl#8_``cPgXSHQlq;N<lZD>bFXnM>fe68ZEwf+Xekkv~o2QC<{${1VQ|y#jlE5OZk7
zS(+u7k8J075NlA}!TX<i5buCvJmMcI82gAnb7B_}i*p!q9g@{t%(Nqu5ibW2qaF!R
zj?1^<4dzq2!LJGIjbP6Lv8?$)LiV?jAAe*B=K^HlhCSEA&{e=`=3)51EzUWfSec<G
z$X6ZN&jn57QJzf9v-M`oXDJ<y-ehlT3hCxvS0}xLHrI?%IXx*(1x<ZQP8sP;+H*A5
zBxE`-02pL8&DMpSCnJ?{`DxH%7wGaadx+4Xl)L46l%HXW^waqV#N%`Z<tluj7rhjR
z5KiWB0_)WZys*yCbYZL!zx+RJIN^pfvTQeGA9<GSmq<U~q@BQe<_dHUL)1=GGA*oR
z80vne4Uk`}c;VxLcXY~idC2#}{yplwLiI9vz1@iI%DV)&uG<biBHB@oEFf#UU&48f
z6I5rs-R50<r?g4wgW9=$z~4k4$m4(pG%upJS+RSR&d_U|R-Df4vp1qM=qGYHyNbqv
zf3s=)&KMf=y+b)jXA>baq@y4+xsU^#AL3_<!ek>zX8IhSVgD-SKu;rgCFO!Qb=0M^
zGc)@*t&N$G86CQWw~Lk0`hZ6T=+iN0xL~`{2mIySAiJU5Y=GSKOhK+3a?^e?K>L@z
zjTb<p=P37t{Zq&d_885<)1tqf<mTiM_6v}QJnYCx0_VKAoKUVr_!#-<w&f$@%E#ZM
z%^>z>yvF<%FZO1<#_SnsMs7ixkzJOCy&3r9p){ON@%XpFpO}5mN7~mt;8WZ?RK7p2
z#ioId&tEc+d%sLP?3_hgY^utaqCwF8S*3yKz<CuoTSR~HuuYR(<&yasbyKuU=6Np2
z`z6{(<8e9mfvg?4$3frTI!<)-;$6@g57B;>MdwHU`|m`eZ8WHSg!3spuZjGc!1J3l
zj`#2-Bex9uX|xB|!sXeH?U7?b%qiuTA(ztkKZ@;12Wqk9B!h_S`8eDrJL7-{1n^NA
zatO$!{|{n%$ScO#4n2+B5BQko>F{8QruN$O%t;I(r-B?%pNRVE4f*bd`Wigz>g&si
z&y476<P&;`-ia8_+{M6)-9yAr1T(t3hG?BNMQ1qg37dko$9W(+n@utYU6x5XO52|Z
z`k_yzr{agb+Kb4Q@p-^!le7WI1$;<LC4166Vo&18Gi&fGNATN{2-x^_4`Hl_s88$-
z4jCP=tp^}~pvlM4LW2xiCD_k}3}R0vKxd@lgQwx|k-ZPH9?*jFwC1Ka7WI(rdJ%bA
z(1OO5mbTfnc+sW>$0fIWh~$&}18oOvOjiu^06!i$fjL3eF)xapje`nkgx^kZ`4~u2
z8}k`gh60}lPx1EAIXD;hEc|S4OM2gm=HMH?1?`m@`nS<Pa=Z#`LB~Hc^L|C9T-V51
zN$e+ZotL*Cdmn;20>{1r?K99f=pBK4D31SA0Ui?&FM!U#kIvS2Er;w3;LLh}^Bnwb
zKh7~<wv@-g1N&*;7yf+<&QW4N!`(l|coyvm>xa}Hz^qteA99o`a(g)Yc1VQ|=6kBJ
zB@3ZrWi34b9b2YAF9Y8e><ts%`J}7y6g=o#HN0gWo97do38txnZ2OD7YobBHLwRJg
zEhy2ultXzD_-tQ3qH>?@nFN<nv*LT$Pk~O^*@b?=mrI*HG#>Esm`{<9&d;LYndR<Z
zH%mb(M_=G;i`w3NI0H5U=L>@1FQSjabrx*vI2!j#IE~Z)rDp6^KsNUMowo-(Djf|%
z*MTRtc3lDwczeP`BPD=+7umSZT5&oMU5Hk!Oi7`IjNF-G(}LZP`O7J^fSoNvd4Tm-
z9r<vC7Ux!fXx4l$gVSPLR|d|iiNr^gw=p_iARiO!@A6!vzz>|kr<aHiz^9iSeS8Y~
zPqcX|*3v_~)TXr26K9y)Eu{kE3QnG{cgPUIPw6to0KdlI*C3w9x!>Dtoe=vh@z0HT
z74rvA(Yj-<ye-Rxot7oc*NHWP#QQW~><OK=`@O<Xv}4s`8)qd#yyuL6w}E{+_`Nc0
zhGKYI<W6r$p)rZa?ftvh_pvr^E`6zuFZ6-4UR(zFejV0zChgnVe5=9tL4VE}0+)A3
z*2~X%S60&dTVt=dyi4}P#!LB&Pe2zBmlqm`web1Cry&_h;fqK<=L`7U{gK$e(mT<K
z_`<9@f@eNr=)}w9=Q-ovPvi1ENazik3;fqJ=34lGkb(YZyS|I|9?}UTuw5J`U&;SG
z_YV2te!1=A<!VlxWUpHw))RaDTUKoMR3jIDO#=DtSnwFd1wGB$1uItkONtG8a**qe
z<vc)olKVMpN!K4;IcA^XHQHzR!3?*5ewH5bmBR~P1Dzb-Epb1=EKh6;a*gPxg?N|Q
zI<R*t+K=(m$v3C{3X5ngBX*^>oW?Cq%o@3wWDdFlzXR9}J_cVf+fRhPe84~)1)B|C
zZ2^22bjd-qhc20N82c`LkgY3qNdWsz1V?>}!St6#{LE-}*;T%#;l$L2K0}~bhQ|^+
z71{j0oGx`OWo8Ea-|jY?>r`cuW$e)*eoN!_R!fUX*gIuC3hZ2LGR{mN_C~u@oFBm)
zxLt!Du;cPw#2<*w;S2A=e0uG^+?eo2ebyhAdoZr?Vi$Y{hB;*;?&E#nopb_Z27Wbs
zY3v)eFw7A+3ODv?xh(h6xq&hJI(!b>6fe<00$r_1nA6a1k@EQFB|H-!Can_#0%!ss
z5Od*Y{4qYo#W=r&If~@VQvLq-b`M)}gt=|{r(wSXXBl`dMupGcHloMQM6q5H{5`Un
zpk;*PkpY{I--S5z`+(+X%-luu6fw^+doWSN9F7jB-!Y7tldmm7ayoWSo1Xgp=0q_r
zpA&vJ_lf2d`OlA^6Fc?E=G1%La|^_0(y=KY8Qx!rnv6ZrZEcs#TRjskoLA5glUrCv
z&a*lAtq1mi;8$jKjw=u}<tu`b3waJg4=Bo=bS}Y`^Vp-%T{chA?=-Rn(23R-zA>Fo
znLk6)(gM)QGo(>D7LbE#ap>RsU$!g@k~t{{HUNAZNs;9Pt}MfsiDX0ny^tcyWzw}}
znc%38wnoQGI1}sSQ!po+R|b;4X7I{%*i*<!r&qZI9=U3t6@0<>-fjCAC?+0<t^1Ah
zU4-{xn+D33R2rn%JJ3MD865#Wn}FOa=FDwrfMUThJO^DONy|a|Fwr;oB?G#X%PDA1
z=Xa=23Fr2r2V+<ZB|`M4n3{Ac#l_slbG^}f9PuD;3%jP6$Vrk8;QGVvyYgCn-?-1n
z4=jcHWR&|QT8+pP^v1}(Cg#L*l=d7Wq))hBC!ago4V~MafZq>4aOY|G-q`D(rpn~M
zz!!^f+lKvr>~lg7;~ZY@QtbT%;gcdCfPEmTyB%kPV&Gkm5Ir{4iN_LQo=Z5#_tw)#
z>kHSZudGX{?;*R^1De2JuH^5NU;Z8RNENq>1F%1_;2^h)Cl2(X&US7WV>ss*oBXnC
z7irF*i`Srh&`=jMRP3|EpT&Hz?*|^^Iihe%j%Z*cN2IB4j!1EGM4-<|jwpCVj>vAu
zb3O1M$Tn!Z4_}cZI(0>kXtWPIN92r6`64yI_cBP{NM0Mkm$bf^56^2L&gXTY2l0gM
zY<2Rm(DAO!Nu3JM#X4sYHec-<NFA_&BjdPZ5Ut1ZO27~M0DX=zv40Q#8o|SsrR({-
zha6kkyIksy35bIs^f;Hv*L3oFP5lnX&mD_oU2^T`RXNpWC#M>@Mou+`JrgIVdO0Ph
zsw#-F$d)2U2%pKAZO81u<x;d8`4!|~`R~u$5Z|tQgPE#FHV)#qcHJi~8QBT&_KC4`
z1>Tx+Egw42qQREHp13-5+m$lr=%HrlT=W5)pg(xdjp75+7o<m!hogFkL7T}Bv+ZB+
zM$l(8{|%juGQ^qC?>W5fM`Wk%{u7(*{-L9t{vl7?F7Pp-lVB(C+dlNceYX}jPY(aM
z1!oR0W-pi3Ezw|$XnGaVd@P2XQVaQID2IQ%_6VNfx2?#{I{9eeClk-4_`a8^zRQPh
zOn7B|cinATu@CHc1$?#?d=^7|lmWks=n<RD&qz(>{;YJ;h9$5MaUZi`KR6N1MZ4S}
zZ%6x`Hhl5xJp<B9R;;|0>x}YqkHLSQ&vnK?aW?$t@myyd{w?5%-V~j|>CO3FjWJ6F
zFM#eN@qG4v>@)N^agcpZ2WO2^&*<1R2c1Yal8;2ZAMJ_>mWs9G=aL{pYM)E*bwnGN
zjxJreJmdsvZvZk4nkYK<47zZ}Fp_p-SwX(&y892o(R|ThVv3*qTH1fOQ9kQHN<QoT
zE<2wEoU|BtBSjYwkD0AqS@=zMW-5Ns-z%S`jLPzcM23wY&u7_tu4*tPp9R`{Om6QJ
z=d<eHP|5fD*nHMZJD<hn=|C5!0p+fYHmuPYTCg$Sj(m>Yr{VrU<W5ZqK<1fX%N`55
z>rebg>uzqv{siUBIuiCb{CS)+8q<GI%+5vfXP2Enq<5S#lC;5V=k($+*p9Z8oZeU8
zNFSlWzR{c>om0Z!0~xY_C&@@EF8%wI!9U8_kGvs%lCiIx_x0(@X1jExc#xmJ%#msD
zL;a)RyXlS0kH;7Jfsu6!I)9rZM!!vk{{#8Kz96lssj4`04cw;vk@D1+Qf%OL<eJAR
zy3IorV}e%PuaI(LZmv%vobY?dVf<!s@cML)OaPAxI2Vezfa1h+Nz+Svm_hI!@?)^O
zWE<X`rSrcFC&Q1a%G6n?u`%4xR9#oASJZ^pHt7#{L>JFjpRD+gyPo{}^Y8unR=uHm
zT~$+szBW`{6RupOH#V3H)`zNV^BNji1^%8Ljv_D|+h%ZySWWeshET)i1)-XnI&%Tl
zYzS>!y&-I(vKgumnbl33^|}q=hP5?y8&Q8R+E2jq5j>~kIYS)Vk6G6c=H0Aa-?X5%
zc|E#W#Hw`EWNda=XQ<B1P;G5plim<En;ROdH-u|8>ml<i&D9NIeSLFNcvF3-w%U9+
zT&ahebhqt07*9Z3_nDucUyxsz@5?XBFU~K?_ve@9FD%F}C@3f_@D&sl6c>~f_zOx4
z78d3g78Dj1`U;B*iwjE%{e`843w`;%0$-ue=PU9R`$~L%U#V|lQGQWDQDKp<sHmv8
zsHDhWR9dvKIKQ}{xUkq)TvS|KTvF^WE-hYIl3!9#Qdr_EDJm&0DJk)nl$I>?=lcu%
zg?^vE$Y1O)@%#Oy{)MIar3IyhrM}Xl(&EyRQh#Y_>B5CTaUq6Zh^`l+*+PKUhH4ta
zO%2Uq9oL<Aj$OKRU8e<Jq^H~PMLNp|9gx0f<3c){iswu`u^qxjs^Z<PbDvXpiBrd|
zJ71rl{)PY35UO1l)*G8b4NZD=ZDn|quGcj;>2+&$yJT%$gWgzEZH5U{6Rus?M9a7V
zeNDs|+wh!;=PS4AoR^3<H_gx)%huVnT;RD0Wf=b!z^ic+u1!@9;ZUVMYe6~qw{Zam
z4zF))s%xnGYE|>Y3pUm@JiK5<bHl?cLTeT@)>l>6Zd&lwhc~QW5Uy=%*j!&%UE9PN
zt8p_Jv!<qTK~<=xiCCJQ3+e2$=pR4-WcWGb$afI$M4La-c-3_ntzwPNR-n(@aNmV{
zR2E%nTlrTjR|Wra^~zOc_pj3Lx>K(Thw4|?*ERl;uvi~nU)Qji&-*lRxeqwpj+<ne
z$@+*qH#SvrYT2?>UAqn~?ylQ(N9E>Py{vZgU3WCs)`r%HEAN`6r;6L6bo}P=Y)I#S
z8uM$W&guDeJV|c<22YYf2yb|i-q2jDZ>$DWRNP;_a@Fd)%NGB|s{6|p2k$JX(8IMG
zsvGKR*JJ7Q4WWkW(3+aC-c+YoRyWqygdpzvnvnT$Q$xrMW4!O6Us}Hvc#=+O#bCGM
znN={#TPyC;*}M5VpxCg)y?43J(nm30+Z1lFC$eZ!sAgkmbK~mJn!1Lj*>mRW{Dmlh
zp`bu@`j?ef>Z|}yhbKpR+E@jhsn<8unc>DpG_pI*8`H@nXj?ei)(kZ_LRr<;)!yD*
zyAh&voo4L2Xh&<cHq;cVA^J5{uMg|thK9NZkaHsx@WVR&gU(3!Ha1i@p{sOu4(%48
z9mJo@8_62o_kaeeG&)#_znALMSp>8~2kS#kL>1mYTLs-a9&KjhCh@@-75CPY5m~ed
zST}^~XV0n7VNybR#b@hk!xdP!n&z-;9$a>U@YzC{m$#s~wz0Xs9z+gTE+DiU7jW$j
zMuSqpR7RF~5eWZNj8AsM=AD&wn0RHl2?nZB4?*wOt*-{MmGiI9Rco7TYGBepmyix~
zw5F~xJUT*N`mfOcL+GFMkrz**Pi0Ua^F6H?bpTt1n{+7E`6761Z;{R#!lY(G;MeNf
z>Ly24u|&1u23s>VG&eRa82!g3%!s`+!!<Pv>T1m}=3izK_XKHS-FhwoZGIzqg=$dq
zI>qbjDp6=_6q1{DVc-#J3hT|a)n9?FaJY8)l12KO>ZV4RY4FjeDlj65$fm8+nICie
zXsymZjpsg0^d>xQ)uD4!AL9N4G`qfLb5pp{@fFfp71~Zl-LK(Ey0m`js0@A=?|VVJ
zeRx6}hZ}0a#t!>}df^5zRdX$LyjjHs-mI$(qYHKpc0kATn_-=m;5i95>19_ITY)Ey
z^(3Buj_1#C-;LYx6GEJtSoT%6{a8V?(^tZ9gkZopo9dO#4J38M9b6Suh8tm2O`0Sd
zqc`+rI(rM_kp3RTO*VsgfiB^z_cP%ULAWJD<S_c1zLnofCW)WuqI&ajKLl7l0dUb=
z0=RcRmrO3flP$^Am$cyT4da#g@w<SNP6IrP;MsVs$Ne(k4?)iXeqUvauua@9Jt<qt
zE_Ju(Des;%KGt3o|LO&&J>F^T7jb_G*dz%rOELpZSGV1p{`9zKGQN2e*QIZv+M6#X
zll$-_+*Xa&=eP_5yz1|h$)Ct}dBteCjSIju?`$aD;X}zJz0*bWD+O!_uqFZk7n+}r
z*ZTlp^-sy<Sv&!+_~O_;dD|wGO?xSs?6B+PQ(NkLC%!ulV}5w2i(piTV1y!F1bYdv
z#{qNKhUy;&tQD|3s8Y&0{2cJ-0e9Aik45!|0Dm2Dq>iY5J>ft!&ceF9dnB3M=B&@h
z(Kvv5cl<Nvg0?hnDvfo3Dp3A1$~W2L-1kr_Jy1^bA)A-=FQaQs`0WL38eo-pN57oD
z1pf};m4Fj}0?zr0-j6$QXFmBW>~VPi@1pFH#8?^*0agPT*#x=>j|}itB&8mWrvp|G
z*gaG!WxP_rI|y#iE8vbd9o1H$>_<nF$;a(BV`xI<O(?(P80KcT)$em@f-;)RE|f=(
zCzBDp6HV`-a=h~SqwHOjku13QWaITX;G13rorx)yWOfMG5G-nc4)u=z)Zt}kJ~VeP
z7_1lYBD~W@u<3yP95BL}E^40-*jc~=1W2LBJ%DHZM>6@m4cAlYQHipBD3k5^W?ebo
zR+LAOqkG+MJF<2}iw=~PzJ7HX;q)@f&Y{eaqx({MkILUddHoxsZBxgkxeTK``{Y<!
z5PXt?xdYyTccQ;5pYs7f2soPYi)a)8Y!_e|DX>+5?F6hS1y%*vi-5gJFwl+KJ_1<%
zo5>`}9bE)_9I$PGxilvj(nRcWz=$4b%h%z%fb9b8J{!j6fa?AP@E@hLr}?}K*z173
zl~R|_AMm|D8_^AXo;1cJ6}|-E4z7Vz{>w*M<Ubu9mBK&w0R9Nzr8EXE!sUyAbpXck
zc3|~@9R$p!4dKxW*eifV@Q(S7$of9O=l|bik`ePeV^RH=0H5?<BeFN51AYYflDCt|
zDu>Tpya|`HD0}>!WHKA?sn?1XI{$Q^yZ#d2<!j)dHtS{$!bEbo8Y$mUP?VRSS91Hj
zc?hcu^Gk3SBa|+fx3;j<%+D_g6_+k7zP(@zLimC$Zj}PRudtvvub|k^$bB+LJInJI
z=jGpCOUVkP0A?31EM8Nx&{w%uN7JI)^9ye;ESkesRM$QnhJU<b#S*>1Ps6h^Lbsv1
z(cHj<DR`B$l!gty!s^2Mg4OE_>+>1QLl&Wl<u%k*!qsMZ;i}bZ8xZZVyha<)xTdj@
z<?(;ay7d&MpfYus2cNm2dJVD=C~vHS6VVh}gCRcgMP#QNq~`yx06C-jGWxJDS8hD`
zq<R!f^Z#SuUf2ol6xsDih0#SmJJqA*k05r5JOr8LodbZ&?e9}~r+QFr_Wwz++Sa4^
z<d<7d#~1ZY_4Yohvt6h+1MlwTj++aBTd&utx5=&Kl+our+%ztT&M)e3pYu)+Dx;ft
h9b?wx!LR&^vEx!5x|ZT5+}!JP74RqA4?Nv^{~x>q7Q+Al

literal 0
HcmV?d00001

diff --git a/tests/blake2s-xor-rotate-right-12/src/main.rs b/tests/blake2s-xor-rotate-right-12/src/main.rs
new file mode 100644
index 000000000..75c6ac8b4
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right-12/src/main.rs
@@ -0,0 +1,13 @@
+#![no_main]
+sphinx_zkvm::entrypoint!(main);
+
+use sphinx_zkvm::syscalls::blake2s_xor_rotate_right_12::syscall_blake2s_xor_rotate_right_12;
+
+pub fn main() {
+    let mut a: [u32; 4] = [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
+    let b: [u32; 4] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+
+    syscall_blake2s_xor_rotate_right_12(a.as_mut_ptr(), b.as_ptr());
+
+    assert_eq!(a, [0x4383a06b, 0x6092062c, 0xad923ed2, 0x823feaf3]);
+}
diff --git a/tests/blake2s-xor-rotate-right/Cargo.lock b/tests/blake2s-xor-rotate-right-16/Cargo.lock
similarity index 100%
rename from tests/blake2s-xor-rotate-right/Cargo.lock
rename to tests/blake2s-xor-rotate-right-16/Cargo.lock
diff --git a/tests/blake2s-xor-rotate-right-16/Cargo.toml b/tests/blake2s-xor-rotate-right-16/Cargo.toml
new file mode 100644
index 000000000..4787ff58f
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right-16/Cargo.toml
@@ -0,0 +1,8 @@
+[workspace]
+[package]
+name = "blake2s-xor-rotate-right-16-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-xor-rotate-right/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-right-16/elf/riscv32im-succinct-zkvm-elf
similarity index 100%
rename from tests/blake2s-xor-rotate-right/elf/riscv32im-succinct-zkvm-elf
rename to tests/blake2s-xor-rotate-right-16/elf/riscv32im-succinct-zkvm-elf
diff --git a/tests/blake2s-xor-rotate-right/src/main.rs b/tests/blake2s-xor-rotate-right-16/src/main.rs
similarity index 73%
rename from tests/blake2s-xor-rotate-right/src/main.rs
rename to tests/blake2s-xor-rotate-right-16/src/main.rs
index 3d6834f01..5a6a4d658 100644
--- a/tests/blake2s-xor-rotate-right/src/main.rs
+++ b/tests/blake2s-xor-rotate-right-16/src/main.rs
@@ -1,19 +1,19 @@
 #![no_main]
 sphinx_zkvm::entrypoint!(main);
 
-use sphinx_zkvm::syscalls::blake2s_xor_rotate_right::syscall_blake2s_xor_rotate_right;
+use sphinx_zkvm::syscalls::blake2s_xor_rotate_right_16::syscall_blake2s_xor_rotate_right_16;
 
 pub fn main() {
     let mut a: [u32; 4] = [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
     let b: [u32; 4] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
 
-    syscall_blake2s_xor_rotate_right(a.as_mut_ptr(), b.as_ptr());
+    syscall_blake2s_xor_rotate_right_16(a.as_mut_ptr(), b.as_ptr());
 
     assert_eq!(a, [0xb4383a06, 0xc6092062, 0x2ad923ed, 0x3823feaf]);
 
     // precompile code
     //for _ in 0..10000 {
-    //    syscall_blake2s_xor_rotate_right(a.as_mut_ptr(), b.as_ptr());
+    //    syscall_blake2s_xor_rotate_right_16(a.as_mut_ptr(), b.as_ptr());
     //}
 
     // no-precompile code
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_12.rs
similarity index 64%
rename from zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right.rs
rename to zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_12.rs
index 0c912e620..e74d0ae5c 100644
--- a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right.rs
+++ b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_12.rs
@@ -3,12 +3,12 @@ use core::arch::asm;
 
 #[allow(unused_variables)]
 #[no_mangle]
-pub extern "C" fn syscall_blake2s_xor_rotate_right(left: *mut u32, right: *const u32) {
+pub extern "C" fn syscall_blake2s_xor_rotate_right_12(left: *mut u32, right: *const u32) {
     #[cfg(target_os = "zkvm")]
     unsafe {
         asm!(
         "ecall",
-        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT,
+        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_12,
         in("a0") left,
         in("a1") right
         );
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_16.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_16.rs
new file mode 100644
index 000000000..4d04d4057
--- /dev/null
+++ b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_16.rs
@@ -0,0 +1,19 @@
+#[cfg(target_os = "zkvm")]
+use core::arch::asm;
+
+#[allow(unused_variables)]
+#[no_mangle]
+pub extern "C" fn syscall_blake2s_xor_rotate_right_16(left: *mut u32, right: *const u32) {
+    #[cfg(target_os = "zkvm")]
+    unsafe {
+        asm!(
+        "ecall",
+        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_16,
+        in("a0") left,
+        in("a1") right
+        );
+    }
+
+    #[cfg(not(target_os = "zkvm"))]
+    unreachable!()
+}
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 70b605955..59837c0fd 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -16,7 +16,8 @@ mod verify;
 pub mod blake2s_add_2;
 pub mod blake2s_add_3;
 pub mod blake2s_xor_rotate_16;
-pub mod blake2s_xor_rotate_right;
+pub mod blake2s_xor_rotate_right_12;
+pub mod blake2s_xor_rotate_right_16;
 
 pub use bls12_381::*;
 pub use bn254::*;
@@ -112,10 +113,12 @@ pub const BLS12381_G1_DOUBLE: u32 = 0x00_00_01_72;
 /// Executes `BLS12381_G1_DECOMPRESS`.
 pub const BLS12381_G1_DECOMPRESS: u32 = 0x00_01_01_F2;
 
-pub const BLAKE_2S_XOR_ROTATE_RIGHT: u32 = 0x00_01_01_CC;
+pub const BLAKE_2S_XOR_ROTATE_RIGHT_16: u32 = 0x00_01_01_CC;
 
 pub const BLAKE_2S_XOR_ROTATE_16: u32 = 0x00_30_01_CD;
 
 pub const BLAKE_2S_ADD_2: u32 = 0x00_01_01_CE;
 
 pub const BLAKE_2S_ADD_3: u32 = 0x00_01_01_CF;
+
+pub const BLAKE_2S_XOR_ROTATE_RIGHT_12: u32 = 0x00_01_01_EA;

From d176cb99551ed1baf11d628edebbcaea1ec091d5 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 16 Sep 2024 18:39:11 +0300
Subject: [PATCH 13/30] feat: Syscall for xor_right-rotate_8 computation

---
 core/src/runtime/record.rs                    |  23 +-
 core/src/runtime/syscall.rs                   |  16 +-
 core/src/stark/air.rs                         |   9 +-
 core/src/syscall/precompiles/blake2s/mod.rs   |   2 +
 .../precompiles/blake2s/xor_rotate_right_8.rs | 357 ++++++++++++
 core/src/utils/programs.rs                    |   3 +
 tests/blake2s-xor-rotate-right-8/Cargo.lock   | 539 ++++++++++++++++++
 tests/blake2s-xor-rotate-right-8/Cargo.toml   |   8 +
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 0 -> 25140 bytes
 tests/blake2s-xor-rotate-right-8/src/main.rs  |  13 +
 .../syscalls/blake2s_xor_rotate_right_8.rs    |  19 +
 zkvm/entrypoint/src/syscalls/mod.rs           |   3 +
 12 files changed, 989 insertions(+), 3 deletions(-)
 create mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_right_8.rs
 create mode 100644 tests/blake2s-xor-rotate-right-8/Cargo.lock
 create mode 100644 tests/blake2s-xor-rotate-right-8/Cargo.toml
 create mode 100755 tests/blake2s-xor-rotate-right-8/elf/riscv32im-succinct-zkvm-elf
 create mode 100644 tests/blake2s-xor-rotate-right-8/src/main.rs
 create mode 100644 zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_8.rs

diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index 6e7b44e4a..ea5cab2c9 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -13,7 +13,8 @@ use crate::stark::MachineRecord;
 use crate::syscall::precompiles::blake2s::{
     Blake2sAdd2Chip, Blake2sAdd2Event, Blake2sAdd3Chip, Blake2sAdd3Event, Blake2sXorRotate16Chip,
     Blake2sXorRotate16Event, Blake2sXorRotateRight12Chip, Blake2sXorRotateRight12Event,
-    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight16Event,
+    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight16Event, Blake2sXorRotateRight8Chip,
+    Blake2sXorRotateRight8Event,
 };
 use crate::syscall::precompiles::edwards::EdDecompressEvent;
 use crate::syscall::precompiles::keccak256::KeccakPermuteEvent;
@@ -136,6 +137,7 @@ pub struct ExecutionRecord {
     pub blake2s_add_2_events: Vec<Blake2sAdd2Event>,
     pub blake2s_add_3_events: Vec<Blake2sAdd3Event>,
     pub blake2s_xor_rotate_right_12_events: Vec<Blake2sXorRotateRight12Event>,
+    pub blake2s_xor_rotate_right_8_events: Vec<Blake2sXorRotateRight8Event>,
 
     pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
 
@@ -360,6 +362,12 @@ impl EventLens<Blake2sXorRotateRight12Chip> for ExecutionRecord {
     }
 }
 
+impl EventLens<Blake2sXorRotateRight8Chip> for ExecutionRecord {
+    fn events(&self) -> <Blake2sXorRotateRight8Chip as crate::air::WithEvents<'_>>::Events {
+        &self.blake2s_xor_rotate_right_8_events
+    }
+}
+
 pub struct ShardingConfig {
     pub shard_size: usize,
     pub add_len: usize,
@@ -531,6 +539,11 @@ impl MachineRecord for ExecutionRecord {
             self.blake2s_xor_rotate_right_12_events.len(),
         );
 
+        stats.insert(
+            "blake2s_xor_rotate_right_8_events".to_string(),
+            self.blake2s_xor_rotate_right_8_events.len(),
+        );
+
         stats
     }
 
@@ -587,6 +600,8 @@ impl MachineRecord for ExecutionRecord {
             .append(&mut other.blake2s_add_3_events);
         self.blake2s_xor_rotate_right_12_events
             .append(&mut other.blake2s_xor_rotate_right_12_events);
+        self.blake2s_xor_rotate_right_8_events
+            .append(&mut other.blake2s_xor_rotate_right_8_events);
 
         // Merge the byte lookups.
         for (shard, events_map) in take(&mut other.byte_lookups) {
@@ -946,6 +961,12 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
+        // blake2s_xor_rotate_right_8 events
+        first.blake2s_xor_rotate_right_8_events = take(&mut self.blake2s_xor_rotate_right_8_events);
+        for (i, event) in first.blake2s_xor_rotate_right_8_events.iter().enumerate() {
+            self.nonce_lookup.insert(event.lookup_id, i as u32);
+        }
+
         // Put MemoryInit / MemoryFinalize events in the last shard.
         let last = shards.last_mut().unwrap();
         last.memory_initialize_events
diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 25b9a0849..e07384a2a 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -8,7 +8,7 @@ use crate::runtime::{Register, Runtime};
 use crate::stark::Ed25519Parameters;
 use crate::syscall::precompiles::blake2s::{
     Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRight12Chip,
-    Blake2sXorRotateRight16Chip,
+    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight8Chip,
 };
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::bls12_381::g2_add::Bls12381G2AffineAddChip;
@@ -130,6 +130,7 @@ pub enum SyscallCode {
     BLAKE_2S_ADD_3 = 0x00_01_01_CF,
 
     BLAKE_2S_XOR_ROTATE_RIGHT_12 = 0x00_01_01_EA,
+    BLAKE_2S_XOR_ROTATE_RIGHT_8 = 0x00_01_01_EB,
 }
 
 impl SyscallCode {
@@ -171,6 +172,7 @@ impl SyscallCode {
             0x00_01_01_CE => SyscallCode::BLAKE_2S_ADD_2,
             0x00_01_01_CF => SyscallCode::BLAKE_2S_ADD_3,
             0x00_01_01_EA => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12,
+            0x00_01_01_EB => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -434,6 +436,11 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
         Arc::new(Blake2sXorRotateRight12Chip::new()),
     );
 
+    syscall_map.insert(
+        SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8,
+        Arc::new(Blake2sXorRotateRight8Chip::new()),
+    );
+
     syscall_map
 }
 
@@ -573,6 +580,13 @@ mod tests {
                         sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_12
                     )
                 }
+
+                SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8 => {
+                    assert_eq!(
+                        code as u32,
+                        sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_8
+                    )
+                }
             }
         }
     }
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index 60455c427..1335ce915 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -5,7 +5,7 @@ use crate::memory::{MemoryChipType, MemoryProgramChip};
 use crate::stark::Chip;
 use crate::syscall::precompiles::blake2s::{
     Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRight12Chip,
-    Blake2sXorRotateRight16Chip,
+    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight8Chip,
 };
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::field::FieldChip;
@@ -111,11 +111,13 @@ pub enum RiscvAir<F: PrimeField32> {
     /// A precompile for decompressing a point on the BLS12-381 curve.
     Bls12381G1Decompress(Bls12381G1DecompressChip),
 
+    // Blake2s
     Blake2sXorRotateRight16(Blake2sXorRotateRight16Chip),
     Blake2sXorRotate16(Blake2sXorRotate16Chip), // based on sha-extend
     Blake2sAdd2(Blake2sAdd2Chip),
     Blake2sAdd3(Blake2sAdd3Chip),
     Blake2sXorRotateRight12(Blake2sXorRotateRight12Chip),
+    Blake2sXorRotateRight8(Blake2sXorRotateRight8Chip),
 }
 
 impl<F: PrimeField32> RiscvAir<F> {
@@ -211,6 +213,11 @@ impl<F: PrimeField32> RiscvAir<F> {
             blake_2s_xor_rotate_right_12,
         ));
 
+        let blake_2s_xor_rotate_right_8 = Blake2sXorRotateRight8Chip::default();
+        chips.push(RiscvAir::Blake2sXorRotateRight8(
+            blake_2s_xor_rotate_right_8,
+        ));
+
         chips
     }
 }
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index c7fae7c72..d9b77afba 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -3,12 +3,14 @@ mod add_3;
 mod xor_rotate_16; // based on sha-extend
 mod xor_rotate_right_12;
 mod xor_rotate_right_16;
+mod xor_rotate_right_8;
 
 pub use add_2::*;
 pub use add_3::*;
 pub use xor_rotate_16::*; // based on sha-extend
 pub use xor_rotate_right_12::*;
 pub use xor_rotate_right_16::*;
+pub use xor_rotate_right_8::*;
 
 #[cfg(test)]
 mod tests {
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_right_8.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_right_8.rs
new file mode 100644
index 000000000..101a9673a
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/xor_rotate_right_8.rs
@@ -0,0 +1,357 @@
+use crate::bytes::event::ByteRecord;
+use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
+use crate::operations::{FixedRotateRightOperation, XorOperation};
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
+use crate::stark::SphinxAirBuilder;
+use crate::utils::pad_rows;
+use crate::{
+    air::{EventLens, MachineAir, WithEvents},
+    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
+};
+use core::borrow::{Borrow, BorrowMut};
+use p3_air::{Air, AirBuilder, BaseAir};
+use p3_field::{AbstractField, PrimeField32};
+use p3_matrix::dense::RowMajorMatrix;
+use p3_matrix::Matrix;
+use serde::Deserialize;
+use serde::Serialize;
+use sphinx_derive::AlignedBorrow;
+use std::mem::size_of;
+
+const R_3: u32 = 8;
+
+#[derive(Default)]
+pub struct Blake2sXorRotateRight8Chip;
+
+impl Blake2sXorRotateRight8Chip {
+    pub fn new() -> Self {
+        Blake2sXorRotateRight8Chip
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Blake2sXorRotateRight8Event {
+    pub lookup_id: usize,
+    pub clk: u32,
+    pub shard: u32,
+    pub channel: u32,
+    pub a_ptr: u32,
+    pub b_ptr: u32,
+    pub a_reads_writes: Vec<MemoryWriteRecord>,
+    pub b_reads: Vec<MemoryReadRecord>,
+}
+
+impl Syscall for Blake2sXorRotateRight8Chip {
+    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
+        let clk_init = ctx.clk;
+        let shard = ctx.current_shard();
+        let lookup_id = ctx.syscall_lookup_id;
+        let channel = ctx.current_channel();
+
+        let a_ptr = arg1;
+        let b_ptr = arg2;
+
+        let a = ctx.slice_unsafe(a_ptr, 4);
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 4);
+
+        let xor = a
+            .into_iter()
+            .zip(b.into_iter())
+            .map(|(a, b)| a ^ b)
+            .collect::<Vec<u32>>();
+
+        let rotate_right = xor
+            .into_iter()
+            .map(|xor_i| xor_i.rotate_right(R_3))
+            .collect::<Vec<u32>>();
+
+        ctx.clk += 1;
+
+        // Write rotate_right to a_ptr.
+        let a_reads_writes = ctx.mw_slice(a_ptr, rotate_right.as_slice());
+
+        ctx.record_mut()
+            .blake2s_xor_rotate_right_8_events
+            .push(Blake2sXorRotateRight8Event {
+                lookup_id,
+                clk: clk_init,
+                shard,
+                channel,
+                a_ptr,
+                b_ptr,
+                a_reads_writes,
+                b_reads,
+            });
+
+        None
+    }
+
+    fn num_extra_cycles(&self) -> u32 {
+        1
+    }
+}
+
+#[derive(Debug, Clone, AlignedBorrow)]
+#[repr(C)]
+struct Blake2sXorRotateRight8Cols<T> {
+    pub clk: T,
+    pub shard: T,
+    pub channel: T,
+    pub nonce: T,
+    pub is_real: T,
+
+    pub a_ptr: T,
+    pub b_ptr: T,
+
+    pub a: [MemoryWriteCols<T>; 4],
+    pub b: [MemoryReadCols<T>; 4],
+
+    pub xor: [XorOperation<T>; 4],
+    pub rotate_right: [FixedRotateRightOperation<T>; 4],
+}
+
+impl<T: PrimeField32> BaseAir<T> for Blake2sXorRotateRight8Chip {
+    fn width(&self) -> usize {
+        size_of::<Blake2sXorRotateRight8Cols<u8>>()
+    }
+}
+
+impl<'a> WithEvents<'a> for Blake2sXorRotateRight8Chip {
+    type Events = &'a [Blake2sXorRotateRight8Event];
+}
+
+impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRight8Chip {
+    type Record = ExecutionRecord;
+    type Program = Program;
+
+    fn name(&self) -> String {
+        "Blake2sXorRotateRight8Chip".to_string()
+    }
+
+    fn generate_trace<EL: EventLens<Self>>(
+        &self,
+        input: &EL,
+        output: &mut Self::Record,
+    ) -> RowMajorMatrix<F> {
+        let mut rows = vec![];
+        let width = <Blake2sXorRotateRight8Chip as BaseAir<F>>::width(self);
+        let mut new_byte_lookup_events = Vec::new();
+        for event in input.events() {
+            let shard = event.shard;
+            let mut row = vec![F::zero(); width];
+            let cols: &mut Blake2sXorRotateRight8Cols<F> = row.as_mut_slice().borrow_mut();
+
+            cols.clk = F::from_canonical_u32(event.clk);
+            cols.is_real = F::one();
+            cols.shard = F::from_canonical_u32(event.shard);
+            cols.channel = F::from_canonical_u32(event.channel);
+            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
+            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
+
+            for i in 0..4usize {
+                cols.a[i].populate(
+                    event.channel,
+                    event.a_reads_writes[i],
+                    &mut new_byte_lookup_events,
+                );
+
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+
+                let a = event.a_reads_writes[i].value;
+                let b = event.b_reads[i].value;
+                let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
+                assert_eq!(a ^ b, xor);
+
+                let rotate_right =
+                    cols.rotate_right[i].populate(output, shard, event.channel, xor, R_3 as usize);
+                assert_eq!(xor.rotate_right(R_3), rotate_right);
+            }
+
+            rows.push(row);
+        }
+
+        output.add_byte_lookup_events(new_byte_lookup_events);
+
+        pad_rows(&mut rows, || {
+            let row = vec![F::zero(); width];
+
+            row
+        });
+
+        let mut trace =
+            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
+
+        // Write the nonces to the trace.
+        for i in 0..trace.height() {
+            let cols: &mut Blake2sXorRotateRight8Cols<F> =
+                trace.values[i * width..(i + 1) * width].borrow_mut();
+            cols.nonce = F::from_canonical_usize(i);
+        }
+
+        trace
+    }
+
+    fn included(&self, shard: &Self::Record) -> bool {
+        !shard.blake2s_xor_rotate_right_8_events.is_empty()
+    }
+}
+
+impl<AB: SphinxAirBuilder> Air<AB> for Blake2sXorRotateRight8Chip
+where
+    AB::F: PrimeField32,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local = main.row_slice(0);
+        let next = main.row_slice(1);
+        let local: &Blake2sXorRotateRight8Cols<AB::Var> = (*local).borrow();
+        let next: &Blake2sXorRotateRight8Cols<AB::Var> = (*next).borrow();
+
+        // Constrain the incrementing nonce.
+        builder.when_first_row().assert_zero(local.nonce);
+        builder
+            .when_transition()
+            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
+
+        for i in 0..4usize {
+            // Eval a
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
+                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.a[i],
+                local.is_real,
+            );
+
+            // Eval b.
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
+
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i].value(),
+                *local.b[i].value(),
+                local.xor[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i].value,
+                R_3 as usize,
+                local.rotate_right[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+        }
+
+        builder.receive_syscall(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.nonce,
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8.syscall_id()),
+            local.a_ptr,
+            local.b_ptr,
+            local.is_real,
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::runtime::{Instruction, Opcode, SyscallCode};
+    use crate::utils::tests::BLAKE2S_XOR_ROTATE_RIGHT_8_ELF;
+    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
+    use crate::Program;
+
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
+        let mut instructions = vec![];
+        // memory write a
+        for (index, word) in a.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                a_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // memory write b
+        for (index, word) in b.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                b_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // Syscall invocation
+        instructions.push(Instruction::new(
+            Opcode::ADD,
+            5,
+            0,
+            SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8 as u32,
+            false,
+            true,
+        ));
+        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
+        Program::new(instructions, 0, 0)
+    }
+
+    #[test]
+    fn test_blake2s_xor_rotate_right_8_precompile() {
+        setup_logger();
+
+        let a_ptr = 100100100;
+        let b_ptr = 200200200;
+        let program = risc_v_program(
+            a_ptr,
+            b_ptr,
+            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+        );
+
+        let (_, memory) = run_test_with_memory_inspection(program);
+        let mut result = vec![];
+        // result is 4 words, written to a_ptr
+        for i in 0..4 {
+            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
+        }
+
+        assert_eq!(
+            result,
+            [0x383a06b4, 0x92062c6, 0xd923ed2a, 0x23feaf38].to_vec()
+        );
+    }
+
+    #[test]
+    fn test_blake2s_xor_rotate_right_8_program() {
+        setup_logger();
+        let program = Program::from(BLAKE2S_XOR_ROTATE_RIGHT_8_ELF);
+        run_test(program).unwrap();
+    }
+}
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index cfc4b3ef4..f58116bf6 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -138,6 +138,9 @@ pub mod tests {
         "../../../tests/blake2s-xor-rotate-right-12/elf/riscv32im-succinct-zkvm-elf"
     );
 
+    pub const BLAKE2S_XOR_ROTATE_RIGHT_8_ELF: &[u8] =
+        include_bytes!("../../../tests/blake2s-xor-rotate-right-8/elf/riscv32im-succinct-zkvm-elf");
+
     pub const PANIC_ELF: &[u8] =
         include_bytes!("../../../tests/panic/elf/riscv32im-succinct-zkvm-elf");
 }
diff --git a/tests/blake2s-xor-rotate-right-8/Cargo.lock b/tests/blake2s-xor-rotate-right-8/Cargo.lock
new file mode 100644
index 000000000..76e896b8b
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right-8/Cargo.lock
@@ -0,0 +1,539 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2s-xor-rotate-right-8-test"
+version = "0.1.0"
+dependencies = [
+ "sphinx-zkvm",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest",
+ "elliptic-curve",
+ "rfc6979",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest",
+ "ff",
+ "generic-array",
+ "group",
+ "pkcs8",
+ "rand_core",
+ "sec1",
+ "subtle",
+ "tap",
+ "zeroize",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "bitvec",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.2.0-rc.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "once_cell",
+ "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "signature",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "once_cell"
+version = "1.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "sphinx-precompiles"
+version = "1.0.0"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "hybrid-array",
+ "k256",
+ "serde",
+]
+
+[[package]]
+name = "sphinx-zkvm"
+version = "1.0.0"
+dependencies = [
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "k256",
+ "lazy_static",
+ "libm",
+ "once_cell",
+ "rand",
+ "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
+ "sphinx-precompiles",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-xor-rotate-right-8/Cargo.toml b/tests/blake2s-xor-rotate-right-8/Cargo.toml
new file mode 100644
index 000000000..82899e0ef
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right-8/Cargo.toml
@@ -0,0 +1,8 @@
+[workspace]
+[package]
+name = "blake2s-xor-rotate-right-8-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-xor-rotate-right-8/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-right-8/elf/riscv32im-succinct-zkvm-elf
new file mode 100755
index 0000000000000000000000000000000000000000..a4271c1948c7a60297340f635de16d5b931fcd57
GIT binary patch
literal 25140
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

literal 0
HcmV?d00001

diff --git a/tests/blake2s-xor-rotate-right-8/src/main.rs b/tests/blake2s-xor-rotate-right-8/src/main.rs
new file mode 100644
index 000000000..987643abe
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right-8/src/main.rs
@@ -0,0 +1,13 @@
+#![no_main]
+sphinx_zkvm::entrypoint!(main);
+
+use sphinx_zkvm::syscalls::blake2s_xor_rotate_right_8::syscall_blake2s_xor_rotate_right_8;
+
+pub fn main() {
+    let mut a: [u32; 4] = [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
+    let b: [u32; 4] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+
+    syscall_blake2s_xor_rotate_right_8(a.as_mut_ptr(), b.as_ptr());
+
+    assert_eq!(a, [0x383a06b4, 0x92062c6, 0xd923ed2a, 0x23feaf38]);
+}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_8.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_8.rs
new file mode 100644
index 000000000..623f6bb4b
--- /dev/null
+++ b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_8.rs
@@ -0,0 +1,19 @@
+#[cfg(target_os = "zkvm")]
+use core::arch::asm;
+
+#[allow(unused_variables)]
+#[no_mangle]
+pub extern "C" fn syscall_blake2s_xor_rotate_right_8(left: *mut u32, right: *const u32) {
+    #[cfg(target_os = "zkvm")]
+    unsafe {
+        asm!(
+        "ecall",
+        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_8,
+        in("a0") left,
+        in("a1") right
+        );
+    }
+
+    #[cfg(not(target_os = "zkvm"))]
+    unreachable!()
+}
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 59837c0fd..0a4737fb5 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -18,6 +18,7 @@ pub mod blake2s_add_3;
 pub mod blake2s_xor_rotate_16;
 pub mod blake2s_xor_rotate_right_12;
 pub mod blake2s_xor_rotate_right_16;
+pub mod blake2s_xor_rotate_right_8;
 
 pub use bls12_381::*;
 pub use bn254::*;
@@ -122,3 +123,5 @@ pub const BLAKE_2S_ADD_2: u32 = 0x00_01_01_CE;
 pub const BLAKE_2S_ADD_3: u32 = 0x00_01_01_CF;
 
 pub const BLAKE_2S_XOR_ROTATE_RIGHT_12: u32 = 0x00_01_01_EA;
+
+pub const BLAKE_2S_XOR_ROTATE_RIGHT_8: u32 = 0x00_01_01_EB;

From d507467d3a3a29b0408475447f18a2cd53b0aff8 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 16 Sep 2024 18:57:11 +0300
Subject: [PATCH 14/30] feat: Syscall for xor_right_rotate_7 computation

---
 core/src/runtime/record.rs                    |  24 +-
 core/src/runtime/syscall.rs                   |  16 +-
 core/src/stark/air.rs                         |   8 +-
 core/src/syscall/precompiles/blake2s/mod.rs   |   2 +
 .../precompiles/blake2s/xor_rotate_right_7.rs | 357 ++++++++++++
 core/src/utils/programs.rs                    |   3 +
 tests/blake2s-xor-rotate-right-7/Cargo.lock   | 539 ++++++++++++++++++
 tests/blake2s-xor-rotate-right-7/Cargo.toml   |   8 +
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 0 -> 25140 bytes
 tests/blake2s-xor-rotate-right-7/src/main.rs  |  13 +
 .../syscalls/blake2s_xor_rotate_right_7.rs    |  19 +
 zkvm/entrypoint/src/syscalls/mod.rs           |   3 +
 zkvm/precompiles/src/lib.rs                   |   5 +-
 13 files changed, 992 insertions(+), 5 deletions(-)
 create mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_right_7.rs
 create mode 100644 tests/blake2s-xor-rotate-right-7/Cargo.lock
 create mode 100644 tests/blake2s-xor-rotate-right-7/Cargo.toml
 create mode 100755 tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf
 create mode 100644 tests/blake2s-xor-rotate-right-7/src/main.rs
 create mode 100644 zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_7.rs

diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index ea5cab2c9..e636402ce 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -13,8 +13,8 @@ use crate::stark::MachineRecord;
 use crate::syscall::precompiles::blake2s::{
     Blake2sAdd2Chip, Blake2sAdd2Event, Blake2sAdd3Chip, Blake2sAdd3Event, Blake2sXorRotate16Chip,
     Blake2sXorRotate16Event, Blake2sXorRotateRight12Chip, Blake2sXorRotateRight12Event,
-    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight16Event, Blake2sXorRotateRight8Chip,
-    Blake2sXorRotateRight8Event,
+    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight16Event, Blake2sXorRotateRight7Chip,
+    Blake2sXorRotateRight7Event, Blake2sXorRotateRight8Chip, Blake2sXorRotateRight8Event,
 };
 use crate::syscall::precompiles::edwards::EdDecompressEvent;
 use crate::syscall::precompiles::keccak256::KeccakPermuteEvent;
@@ -138,6 +138,7 @@ pub struct ExecutionRecord {
     pub blake2s_add_3_events: Vec<Blake2sAdd3Event>,
     pub blake2s_xor_rotate_right_12_events: Vec<Blake2sXorRotateRight12Event>,
     pub blake2s_xor_rotate_right_8_events: Vec<Blake2sXorRotateRight8Event>,
+    pub blake2s_xor_rotate_right_7_events: Vec<Blake2sXorRotateRight7Event>,
 
     pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
 
@@ -368,6 +369,12 @@ impl EventLens<Blake2sXorRotateRight8Chip> for ExecutionRecord {
     }
 }
 
+impl EventLens<Blake2sXorRotateRight7Chip> for ExecutionRecord {
+    fn events(&self) -> <Blake2sXorRotateRight7Chip as crate::air::WithEvents<'_>>::Events {
+        &self.blake2s_xor_rotate_right_7_events
+    }
+}
+
 pub struct ShardingConfig {
     pub shard_size: usize,
     pub add_len: usize,
@@ -544,6 +551,11 @@ impl MachineRecord for ExecutionRecord {
             self.blake2s_xor_rotate_right_8_events.len(),
         );
 
+        stats.insert(
+            "blake2s_xor_rotate_right_7_events".to_string(),
+            self.blake2s_xor_rotate_right_7_events.len(),
+        );
+
         stats
     }
 
@@ -602,6 +614,8 @@ impl MachineRecord for ExecutionRecord {
             .append(&mut other.blake2s_xor_rotate_right_12_events);
         self.blake2s_xor_rotate_right_8_events
             .append(&mut other.blake2s_xor_rotate_right_8_events);
+        self.blake2s_xor_rotate_right_7_events
+            .append(&mut other.blake2s_xor_rotate_right_7_events);
 
         // Merge the byte lookups.
         for (shard, events_map) in take(&mut other.byte_lookups) {
@@ -967,6 +981,12 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
+        // blake2s_xor_rotate_right_7 events
+        first.blake2s_xor_rotate_right_7_events = take(&mut self.blake2s_xor_rotate_right_7_events);
+        for (i, event) in first.blake2s_xor_rotate_right_7_events.iter().enumerate() {
+            self.nonce_lookup.insert(event.lookup_id, i as u32);
+        }
+
         // Put MemoryInit / MemoryFinalize events in the last shard.
         let last = shards.last_mut().unwrap();
         last.memory_initialize_events
diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index e07384a2a..89b098e23 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -8,7 +8,7 @@ use crate::runtime::{Register, Runtime};
 use crate::stark::Ed25519Parameters;
 use crate::syscall::precompiles::blake2s::{
     Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRight12Chip,
-    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight8Chip,
+    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight7Chip, Blake2sXorRotateRight8Chip,
 };
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::bls12_381::g2_add::Bls12381G2AffineAddChip;
@@ -131,6 +131,7 @@ pub enum SyscallCode {
 
     BLAKE_2S_XOR_ROTATE_RIGHT_12 = 0x00_01_01_EA,
     BLAKE_2S_XOR_ROTATE_RIGHT_8 = 0x00_01_01_EB,
+    BLAKE_2S_XOR_ROTATE_RIGHT_7 = 0x00_01_01_EC,
 }
 
 impl SyscallCode {
@@ -173,6 +174,7 @@ impl SyscallCode {
             0x00_01_01_CF => SyscallCode::BLAKE_2S_ADD_3,
             0x00_01_01_EA => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12,
             0x00_01_01_EB => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8,
+            0x00_01_01_EC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -441,6 +443,11 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
         Arc::new(Blake2sXorRotateRight8Chip::new()),
     );
 
+    syscall_map.insert(
+        SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7,
+        Arc::new(Blake2sXorRotateRight7Chip::new()),
+    );
+
     syscall_map
 }
 
@@ -587,6 +594,13 @@ mod tests {
                         sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_8
                     )
                 }
+
+                SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7 => {
+                    assert_eq!(
+                        code as u32,
+                        sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_7
+                    )
+                }
             }
         }
     }
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index 1335ce915..e8ba4907c 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -5,7 +5,7 @@ use crate::memory::{MemoryChipType, MemoryProgramChip};
 use crate::stark::Chip;
 use crate::syscall::precompiles::blake2s::{
     Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRight12Chip,
-    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight8Chip,
+    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight7Chip, Blake2sXorRotateRight8Chip,
 };
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::field::FieldChip;
@@ -118,6 +118,7 @@ pub enum RiscvAir<F: PrimeField32> {
     Blake2sAdd3(Blake2sAdd3Chip),
     Blake2sXorRotateRight12(Blake2sXorRotateRight12Chip),
     Blake2sXorRotateRight8(Blake2sXorRotateRight8Chip),
+    Blake2sXorRotateRight7(Blake2sXorRotateRight7Chip),
 }
 
 impl<F: PrimeField32> RiscvAir<F> {
@@ -218,6 +219,11 @@ impl<F: PrimeField32> RiscvAir<F> {
             blake_2s_xor_rotate_right_8,
         ));
 
+        let blake_2s_xor_rotate_right_7 = Blake2sXorRotateRight7Chip::default();
+        chips.push(RiscvAir::Blake2sXorRotateRight7(
+            blake_2s_xor_rotate_right_7,
+        ));
+
         chips
     }
 }
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index d9b77afba..2d5a55ed8 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -3,6 +3,7 @@ mod add_3;
 mod xor_rotate_16; // based on sha-extend
 mod xor_rotate_right_12;
 mod xor_rotate_right_16;
+mod xor_rotate_right_7;
 mod xor_rotate_right_8;
 
 pub use add_2::*;
@@ -10,6 +11,7 @@ pub use add_3::*;
 pub use xor_rotate_16::*; // based on sha-extend
 pub use xor_rotate_right_12::*;
 pub use xor_rotate_right_16::*;
+pub use xor_rotate_right_7::*;
 pub use xor_rotate_right_8::*;
 
 #[cfg(test)]
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_right_7.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_right_7.rs
new file mode 100644
index 000000000..387dc7e5f
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/xor_rotate_right_7.rs
@@ -0,0 +1,357 @@
+use crate::bytes::event::ByteRecord;
+use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
+use crate::operations::{FixedRotateRightOperation, XorOperation};
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
+use crate::stark::SphinxAirBuilder;
+use crate::utils::pad_rows;
+use crate::{
+    air::{EventLens, MachineAir, WithEvents},
+    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
+};
+use core::borrow::{Borrow, BorrowMut};
+use p3_air::{Air, AirBuilder, BaseAir};
+use p3_field::{AbstractField, PrimeField32};
+use p3_matrix::dense::RowMajorMatrix;
+use p3_matrix::Matrix;
+use serde::Deserialize;
+use serde::Serialize;
+use sphinx_derive::AlignedBorrow;
+use std::mem::size_of;
+
+const R_4: u32 = 7;
+
+#[derive(Default)]
+pub struct Blake2sXorRotateRight7Chip;
+
+impl Blake2sXorRotateRight7Chip {
+    pub fn new() -> Self {
+        Blake2sXorRotateRight7Chip
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Blake2sXorRotateRight7Event {
+    pub lookup_id: usize,
+    pub clk: u32,
+    pub shard: u32,
+    pub channel: u32,
+    pub a_ptr: u32,
+    pub b_ptr: u32,
+    pub a_reads_writes: Vec<MemoryWriteRecord>,
+    pub b_reads: Vec<MemoryReadRecord>,
+}
+
+impl Syscall for Blake2sXorRotateRight7Chip {
+    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
+        let clk_init = ctx.clk;
+        let shard = ctx.current_shard();
+        let lookup_id = ctx.syscall_lookup_id;
+        let channel = ctx.current_channel();
+
+        let a_ptr = arg1;
+        let b_ptr = arg2;
+
+        let a = ctx.slice_unsafe(a_ptr, 4);
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 4);
+
+        let xor = a
+            .into_iter()
+            .zip(b.into_iter())
+            .map(|(a, b)| a ^ b)
+            .collect::<Vec<u32>>();
+
+        let rotate_right = xor
+            .into_iter()
+            .map(|xor_i| xor_i.rotate_right(R_4))
+            .collect::<Vec<u32>>();
+
+        ctx.clk += 1;
+
+        // Write rotate_right to a_ptr.
+        let a_reads_writes = ctx.mw_slice(a_ptr, rotate_right.as_slice());
+
+        ctx.record_mut()
+            .blake2s_xor_rotate_right_7_events
+            .push(Blake2sXorRotateRight7Event {
+                lookup_id,
+                clk: clk_init,
+                shard,
+                channel,
+                a_ptr,
+                b_ptr,
+                a_reads_writes,
+                b_reads,
+            });
+
+        None
+    }
+
+    fn num_extra_cycles(&self) -> u32 {
+        1
+    }
+}
+
+#[derive(Debug, Clone, AlignedBorrow)]
+#[repr(C)]
+struct Blake2sXorRotateRight7Cols<T> {
+    pub clk: T,
+    pub shard: T,
+    pub channel: T,
+    pub nonce: T,
+    pub is_real: T,
+
+    pub a_ptr: T,
+    pub b_ptr: T,
+
+    pub a: [MemoryWriteCols<T>; 4],
+    pub b: [MemoryReadCols<T>; 4],
+
+    pub xor: [XorOperation<T>; 4],
+    pub rotate_right: [FixedRotateRightOperation<T>; 4],
+}
+
+impl<T: PrimeField32> BaseAir<T> for Blake2sXorRotateRight7Chip {
+    fn width(&self) -> usize {
+        size_of::<Blake2sXorRotateRight7Cols<u8>>()
+    }
+}
+
+impl<'a> WithEvents<'a> for Blake2sXorRotateRight7Chip {
+    type Events = &'a [Blake2sXorRotateRight7Event];
+}
+
+impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRight7Chip {
+    type Record = ExecutionRecord;
+    type Program = Program;
+
+    fn name(&self) -> String {
+        "Blake2sXorRotateRight7Chip".to_string()
+    }
+
+    fn generate_trace<EL: EventLens<Self>>(
+        &self,
+        input: &EL,
+        output: &mut Self::Record,
+    ) -> RowMajorMatrix<F> {
+        let mut rows = vec![];
+        let width = <Blake2sXorRotateRight7Chip as BaseAir<F>>::width(self);
+        let mut new_byte_lookup_events = Vec::new();
+        for event in input.events() {
+            let shard = event.shard;
+            let mut row = vec![F::zero(); width];
+            let cols: &mut Blake2sXorRotateRight7Cols<F> = row.as_mut_slice().borrow_mut();
+
+            cols.clk = F::from_canonical_u32(event.clk);
+            cols.is_real = F::one();
+            cols.shard = F::from_canonical_u32(event.shard);
+            cols.channel = F::from_canonical_u32(event.channel);
+            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
+            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
+
+            for i in 0..4usize {
+                cols.a[i].populate(
+                    event.channel,
+                    event.a_reads_writes[i],
+                    &mut new_byte_lookup_events,
+                );
+
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+
+                let a = event.a_reads_writes[i].value;
+                let b = event.b_reads[i].value;
+                let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
+                assert_eq!(a ^ b, xor);
+
+                let rotate_right =
+                    cols.rotate_right[i].populate(output, shard, event.channel, xor, R_4 as usize);
+                assert_eq!(xor.rotate_right(R_4), rotate_right);
+            }
+
+            rows.push(row);
+        }
+
+        output.add_byte_lookup_events(new_byte_lookup_events);
+
+        pad_rows(&mut rows, || {
+            let row = vec![F::zero(); width];
+
+            row
+        });
+
+        let mut trace =
+            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
+
+        // Write the nonces to the trace.
+        for i in 0..trace.height() {
+            let cols: &mut Blake2sXorRotateRight7Cols<F> =
+                trace.values[i * width..(i + 1) * width].borrow_mut();
+            cols.nonce = F::from_canonical_usize(i);
+        }
+
+        trace
+    }
+
+    fn included(&self, shard: &Self::Record) -> bool {
+        !shard.blake2s_xor_rotate_right_7_events.is_empty()
+    }
+}
+
+impl<AB: SphinxAirBuilder> Air<AB> for Blake2sXorRotateRight7Chip
+where
+    AB::F: PrimeField32,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local = main.row_slice(0);
+        let next = main.row_slice(1);
+        let local: &Blake2sXorRotateRight7Cols<AB::Var> = (*local).borrow();
+        let next: &Blake2sXorRotateRight7Cols<AB::Var> = (*next).borrow();
+
+        // Constrain the incrementing nonce.
+        builder.when_first_row().assert_zero(local.nonce);
+        builder
+            .when_transition()
+            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
+
+        for i in 0..4usize {
+            // Eval a
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
+                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.a[i],
+                local.is_real,
+            );
+
+            // Eval b.
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
+
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i].value(),
+                *local.b[i].value(),
+                local.xor[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i].value,
+                R_4 as usize,
+                local.rotate_right[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+        }
+
+        builder.receive_syscall(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.nonce,
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7.syscall_id()),
+            local.a_ptr,
+            local.b_ptr,
+            local.is_real,
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::runtime::{Instruction, Opcode, SyscallCode};
+    use crate::utils::tests::BLAKE2S_XOR_ROTATE_RIGHT_7_ELF;
+    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
+    use crate::Program;
+
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
+        let mut instructions = vec![];
+        // memory write a
+        for (index, word) in a.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                a_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // memory write b
+        for (index, word) in b.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                b_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // Syscall invocation
+        instructions.push(Instruction::new(
+            Opcode::ADD,
+            5,
+            0,
+            SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7 as u32,
+            false,
+            true,
+        ));
+        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
+        Program::new(instructions, 0, 0)
+    }
+
+    #[test]
+    fn test_blake2s_xor_rotate_right_7_precompile() {
+        setup_logger();
+
+        let a_ptr = 100100100;
+        let b_ptr = 200200200;
+        let program = risc_v_program(
+            a_ptr,
+            b_ptr,
+            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+        );
+
+        let (_, memory) = run_test_with_memory_inspection(program);
+        let mut result = vec![];
+        // result is 4 words, written to a_ptr
+        for i in 0..4 {
+            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
+        }
+
+        assert_eq!(
+            result,
+            [0x70740d68, 0x1240c58c, 0xb247da55, 0x47fd5e70].to_vec()
+        );
+    }
+
+    #[test]
+    fn test_blake2s_xor_rotate_right_7_program() {
+        setup_logger();
+        let program = Program::from(BLAKE2S_XOR_ROTATE_RIGHT_7_ELF);
+        run_test(program).unwrap();
+    }
+}
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index f58116bf6..6cfcd9cf4 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -141,6 +141,9 @@ pub mod tests {
     pub const BLAKE2S_XOR_ROTATE_RIGHT_8_ELF: &[u8] =
         include_bytes!("../../../tests/blake2s-xor-rotate-right-8/elf/riscv32im-succinct-zkvm-elf");
 
+    pub const BLAKE2S_XOR_ROTATE_RIGHT_7_ELF: &[u8] =
+        include_bytes!("../../../tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf");
+
     pub const PANIC_ELF: &[u8] =
         include_bytes!("../../../tests/panic/elf/riscv32im-succinct-zkvm-elf");
 }
diff --git a/tests/blake2s-xor-rotate-right-7/Cargo.lock b/tests/blake2s-xor-rotate-right-7/Cargo.lock
new file mode 100644
index 000000000..78535c876
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right-7/Cargo.lock
@@ -0,0 +1,539 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2s-xor-rotate-right-7-test"
+version = "0.1.0"
+dependencies = [
+ "sphinx-zkvm",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest",
+ "elliptic-curve",
+ "rfc6979",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest",
+ "ff",
+ "generic-array",
+ "group",
+ "pkcs8",
+ "rand_core",
+ "sec1",
+ "subtle",
+ "tap",
+ "zeroize",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "bitvec",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.2.0-rc.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "once_cell",
+ "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "signature",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "once_cell"
+version = "1.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "sphinx-precompiles"
+version = "1.0.0"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "hybrid-array",
+ "k256",
+ "serde",
+]
+
+[[package]]
+name = "sphinx-zkvm"
+version = "1.0.0"
+dependencies = [
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "k256",
+ "lazy_static",
+ "libm",
+ "once_cell",
+ "rand",
+ "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
+ "sphinx-precompiles",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-xor-rotate-right-7/Cargo.toml b/tests/blake2s-xor-rotate-right-7/Cargo.toml
new file mode 100644
index 000000000..a50846983
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right-7/Cargo.toml
@@ -0,0 +1,8 @@
+[workspace]
+[package]
+name = "blake2s-xor-rotate-right-7-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf
new file mode 100755
index 0000000000000000000000000000000000000000..ffbd8e740a3cf08895ea2de803b385e433165ae8
GIT binary patch
literal 25140
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

literal 0
HcmV?d00001

diff --git a/tests/blake2s-xor-rotate-right-7/src/main.rs b/tests/blake2s-xor-rotate-right-7/src/main.rs
new file mode 100644
index 000000000..800270450
--- /dev/null
+++ b/tests/blake2s-xor-rotate-right-7/src/main.rs
@@ -0,0 +1,13 @@
+#![no_main]
+sphinx_zkvm::entrypoint!(main);
+
+use sphinx_zkvm::syscalls::blake2s_xor_rotate_right_7::syscall_blake2s_xor_rotate_right_7;
+
+pub fn main() {
+    let mut a: [u32; 4] = [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
+    let b: [u32; 4] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+
+    syscall_blake2s_xor_rotate_right_7(a.as_mut_ptr(), b.as_ptr());
+
+    assert_eq!(a, [0x70740d68, 0x1240c58c, 0xb247da55, 0x47fd5e70]);
+}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_7.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_7.rs
new file mode 100644
index 000000000..be2aee1fa
--- /dev/null
+++ b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_7.rs
@@ -0,0 +1,19 @@
+#[cfg(target_os = "zkvm")]
+use core::arch::asm;
+
+#[allow(unused_variables)]
+#[no_mangle]
+pub extern "C" fn syscall_blake2s_xor_rotate_right_7(left: *mut u32, right: *const u32) {
+    #[cfg(target_os = "zkvm")]
+    unsafe {
+        asm!(
+        "ecall",
+        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_7,
+        in("a0") left,
+        in("a1") right
+        );
+    }
+
+    #[cfg(not(target_os = "zkvm"))]
+    unreachable!()
+}
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 0a4737fb5..2ca7703bd 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -18,6 +18,7 @@ pub mod blake2s_add_3;
 pub mod blake2s_xor_rotate_16;
 pub mod blake2s_xor_rotate_right_12;
 pub mod blake2s_xor_rotate_right_16;
+pub mod blake2s_xor_rotate_right_7;
 pub mod blake2s_xor_rotate_right_8;
 
 pub use bls12_381::*;
@@ -125,3 +126,5 @@ pub const BLAKE_2S_ADD_3: u32 = 0x00_01_01_CF;
 pub const BLAKE_2S_XOR_ROTATE_RIGHT_12: u32 = 0x00_01_01_EA;
 
 pub const BLAKE_2S_XOR_ROTATE_RIGHT_8: u32 = 0x00_01_01_EB;
+
+pub const BLAKE_2S_XOR_ROTATE_RIGHT_7: u32 = 0x00_01_01_EC;
diff --git a/zkvm/precompiles/src/lib.rs b/zkvm/precompiles/src/lib.rs
index b0112fd9b..a99fa41d8 100644
--- a/zkvm/precompiles/src/lib.rs
+++ b/zkvm/precompiles/src/lib.rs
@@ -47,8 +47,11 @@ extern "C" {
     pub fn sys_alloc_aligned(bytes: usize, align: usize) -> *mut u8;
     pub fn syscall_bls12381_g2_add(p: *mut u32, q: *const u32);
     pub fn syscall_bls12381_g2_double(p: *mut u32);
-    pub fn syscall_blake2s_xor_rotate_right(left: *mut u32, right: *const u32);
     pub fn syscall_blake2s_xor_rotate_16(w: *mut u32);
     pub fn syscall_blake2s_add_2(left: *mut u32, right: *const u32);
     pub fn syscall_blake2s_add_3(left: *mut u32, right: *const u32);
+    pub fn syscall_blake2s_xor_rotate_right_16(left: *mut u32, right: *const u32);
+    pub fn syscall_blake2s_xor_rotate_right_12(left: *mut u32, right: *const u32);
+    pub fn syscall_blake2s_xor_rotate_right_8(left: *mut u32, right: *const u32);
+    pub fn syscall_blake2s_xor_rotate_right_7(left: *mut u32, right: *const u32);
 }

From 892bafb74ded0d6e9449f7ab9742e2b4920913b5 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Tue, 17 Sep 2024 21:25:21 +0300
Subject: [PATCH 15/30] feat: Add QuarterRound syscall

---
 core/src/runtime/record.rs                    |  23 +-
 core/src/runtime/syscall.rs                   |  16 +-
 core/src/stark/air.rs                         |   9 +-
 core/src/syscall/precompiles/blake2s/mod.rs   |   2 +
 .../precompiles/blake2s/quarter_round.rs      | 580 ++++++++++++++++++
 core/src/utils/programs.rs                    |   3 +
 tests/blake2s-quarter-round/Cargo.lock        | 539 ++++++++++++++++
 tests/blake2s-quarter-round/Cargo.toml        |   8 +
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 0 -> 25476 bytes
 tests/blake2s-quarter-round/src/main.rs       |  13 +
 .../src/syscalls/blake2s_quarter_round.rs     |  19 +
 zkvm/entrypoint/src/syscalls/mod.rs           |   3 +
 zkvm/precompiles/src/lib.rs                   |   2 +
 13 files changed, 1212 insertions(+), 5 deletions(-)
 create mode 100644 core/src/syscall/precompiles/blake2s/quarter_round.rs
 create mode 100644 tests/blake2s-quarter-round/Cargo.lock
 create mode 100644 tests/blake2s-quarter-round/Cargo.toml
 create mode 100755 tests/blake2s-quarter-round/elf/riscv32im-succinct-zkvm-elf
 create mode 100644 tests/blake2s-quarter-round/src/main.rs
 create mode 100644 zkvm/entrypoint/src/syscalls/blake2s_quarter_round.rs

diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index e636402ce..85748a803 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -11,7 +11,8 @@ use crate::runtime::MemoryInitializeFinalizeEvent;
 use crate::runtime::MemoryRecordEnum;
 use crate::stark::MachineRecord;
 use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sAdd2Event, Blake2sAdd3Chip, Blake2sAdd3Event, Blake2sXorRotate16Chip,
+    Blake2sAdd2Chip, Blake2sAdd2Event, Blake2sAdd3Chip, Blake2sAdd3Event,
+    Blake2sQuarterRound2xChip, Blake2sQuarterRound2xEvent, Blake2sXorRotate16Chip,
     Blake2sXorRotate16Event, Blake2sXorRotateRight12Chip, Blake2sXorRotateRight12Event,
     Blake2sXorRotateRight16Chip, Blake2sXorRotateRight16Event, Blake2sXorRotateRight7Chip,
     Blake2sXorRotateRight7Event, Blake2sXorRotateRight8Chip, Blake2sXorRotateRight8Event,
@@ -139,6 +140,7 @@ pub struct ExecutionRecord {
     pub blake2s_xor_rotate_right_12_events: Vec<Blake2sXorRotateRight12Event>,
     pub blake2s_xor_rotate_right_8_events: Vec<Blake2sXorRotateRight8Event>,
     pub blake2s_xor_rotate_right_7_events: Vec<Blake2sXorRotateRight7Event>,
+    pub blake2s_quarter_round_2x_events: Vec<Blake2sQuarterRound2xEvent>,
 
     pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
 
@@ -375,6 +377,12 @@ impl EventLens<Blake2sXorRotateRight7Chip> for ExecutionRecord {
     }
 }
 
+impl EventLens<Blake2sQuarterRound2xChip> for ExecutionRecord {
+    fn events(&self) -> <Blake2sQuarterRound2xChip as crate::air::WithEvents<'_>>::Events {
+        &self.blake2s_quarter_round_2x_events
+    }
+}
+
 pub struct ShardingConfig {
     pub shard_size: usize,
     pub add_len: usize,
@@ -556,6 +564,11 @@ impl MachineRecord for ExecutionRecord {
             self.blake2s_xor_rotate_right_7_events.len(),
         );
 
+        stats.insert(
+            "blake2s_quarter_round_2x_events".to_string(),
+            self.blake2s_quarter_round_2x_events.len(),
+        );
+
         stats
     }
 
@@ -616,6 +629,8 @@ impl MachineRecord for ExecutionRecord {
             .append(&mut other.blake2s_xor_rotate_right_8_events);
         self.blake2s_xor_rotate_right_7_events
             .append(&mut other.blake2s_xor_rotate_right_7_events);
+        self.blake2s_quarter_round_2x_events
+            .append(&mut other.blake2s_quarter_round_2x_events);
 
         // Merge the byte lookups.
         for (shard, events_map) in take(&mut other.byte_lookups) {
@@ -987,6 +1002,12 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
+        // blake2s_quarter_round_2x events
+        first.blake2s_quarter_round_2x_events = take(&mut self.blake2s_quarter_round_2x_events);
+        for (i, event) in first.blake2s_quarter_round_2x_events.iter().enumerate() {
+            self.nonce_lookup.insert(event.lookup_id, i as u32);
+        }
+
         // Put MemoryInit / MemoryFinalize events in the last shard.
         let last = shards.last_mut().unwrap();
         last.memory_initialize_events
diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 89b098e23..40c29982a 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -7,8 +7,9 @@ use strum_macros::EnumIter;
 use crate::runtime::{Register, Runtime};
 use crate::stark::Ed25519Parameters;
 use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRight12Chip,
-    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight7Chip, Blake2sXorRotateRight8Chip,
+    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sQuarterRound2xChip, Blake2sXorRotate16Chip,
+    Blake2sXorRotateRight12Chip, Blake2sXorRotateRight16Chip, Blake2sXorRotateRight7Chip,
+    Blake2sXorRotateRight8Chip,
 };
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::bls12_381::g2_add::Bls12381G2AffineAddChip;
@@ -132,6 +133,7 @@ pub enum SyscallCode {
     BLAKE_2S_XOR_ROTATE_RIGHT_12 = 0x00_01_01_EA,
     BLAKE_2S_XOR_ROTATE_RIGHT_8 = 0x00_01_01_EB,
     BLAKE_2S_XOR_ROTATE_RIGHT_7 = 0x00_01_01_EC,
+    BLAKE_2S_QUARTER_ROUND = 0x00_01_01_ED,
 }
 
 impl SyscallCode {
@@ -175,6 +177,7 @@ impl SyscallCode {
             0x00_01_01_EA => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12,
             0x00_01_01_EB => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8,
             0x00_01_01_EC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7,
+            0x00_01_01_ED => SyscallCode::BLAKE_2S_QUARTER_ROUND,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -448,6 +451,11 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
         Arc::new(Blake2sXorRotateRight7Chip::new()),
     );
 
+    syscall_map.insert(
+        SyscallCode::BLAKE_2S_QUARTER_ROUND,
+        Arc::new(Blake2sQuarterRound2xChip::new()),
+    );
+
     syscall_map
 }
 
@@ -601,6 +609,10 @@ mod tests {
                         sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_7
                     )
                 }
+
+                SyscallCode::BLAKE_2S_QUARTER_ROUND => {
+                    assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_QUARTER_ROUND)
+                }
             }
         }
     }
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index e8ba4907c..cfbc76aaf 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -4,8 +4,9 @@ use crate::air::{MachineAir, SPHINX_PROOF_NUM_PV_ELTS};
 use crate::memory::{MemoryChipType, MemoryProgramChip};
 use crate::stark::Chip;
 use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sXorRotate16Chip, Blake2sXorRotateRight12Chip,
-    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight7Chip, Blake2sXorRotateRight8Chip,
+    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sQuarterRound2xChip, Blake2sXorRotate16Chip,
+    Blake2sXorRotateRight12Chip, Blake2sXorRotateRight16Chip, Blake2sXorRotateRight7Chip,
+    Blake2sXorRotateRight8Chip,
 };
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::field::FieldChip;
@@ -119,6 +120,7 @@ pub enum RiscvAir<F: PrimeField32> {
     Blake2sXorRotateRight12(Blake2sXorRotateRight12Chip),
     Blake2sXorRotateRight8(Blake2sXorRotateRight8Chip),
     Blake2sXorRotateRight7(Blake2sXorRotateRight7Chip),
+    Blake2sQuarterRound2x(Blake2sQuarterRound2xChip),
 }
 
 impl<F: PrimeField32> RiscvAir<F> {
@@ -224,6 +226,9 @@ impl<F: PrimeField32> RiscvAir<F> {
             blake_2s_xor_rotate_right_7,
         ));
 
+        let blake_2s_quarter_round_2x = Blake2sQuarterRound2xChip::default();
+        chips.push(RiscvAir::Blake2sQuarterRound2x(blake_2s_quarter_round_2x));
+
         chips
     }
 }
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 2d5a55ed8..efe9f7126 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -1,5 +1,6 @@
 mod add_2;
 mod add_3;
+mod quarter_round;
 mod xor_rotate_16; // based on sha-extend
 mod xor_rotate_right_12;
 mod xor_rotate_right_16;
@@ -8,6 +9,7 @@ mod xor_rotate_right_8;
 
 pub use add_2::*;
 pub use add_3::*;
+pub use quarter_round::*;
 pub use xor_rotate_16::*; // based on sha-extend
 pub use xor_rotate_right_12::*;
 pub use xor_rotate_right_16::*;
diff --git a/core/src/syscall/precompiles/blake2s/quarter_round.rs b/core/src/syscall/precompiles/blake2s/quarter_round.rs
new file mode 100644
index 000000000..c5a5ba86c
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/quarter_round.rs
@@ -0,0 +1,580 @@
+use crate::bytes::event::ByteRecord;
+use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
+use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation};
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
+use crate::stark::SphinxAirBuilder;
+use crate::utils::pad_rows;
+use crate::{
+    air::{EventLens, MachineAir, WithEvents},
+    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
+};
+use core::borrow::{Borrow, BorrowMut};
+use p3_air::{Air, AirBuilder, BaseAir};
+use p3_field::{AbstractField, PrimeField32};
+use p3_matrix::dense::RowMajorMatrix;
+use p3_matrix::Matrix;
+use serde::Deserialize;
+use serde::Serialize;
+use sphinx_derive::AlignedBorrow;
+use std::mem::size_of;
+
+const R_1: u32 = 16;
+const R_2: u32 = 12;
+//const R_3: u32 = 8;
+//const R_4: u32 = 7;
+
+#[derive(Default)]
+pub struct Blake2sQuarterRound2xChip;
+
+impl Blake2sQuarterRound2xChip {
+    pub fn new() -> Self {
+        Blake2sQuarterRound2xChip
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Blake2sQuarterRound2xEvent {
+    pub lookup_id: usize,
+    pub clk: u32,
+    pub shard: u32,
+    pub channel: u32,
+    pub a_ptr: u32,
+    pub b_ptr: u32,
+
+    pub a_reads_writes: Vec<MemoryWriteRecord>,
+    pub b_reads: Vec<MemoryReadRecord>,
+}
+
+impl Syscall for Blake2sQuarterRound2xChip {
+    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
+        let clk_init = ctx.clk;
+        let shard = ctx.current_shard();
+        let lookup_id = ctx.syscall_lookup_id;
+        let channel = ctx.current_channel();
+
+        let a_ptr = arg1;
+        let b_ptr = arg2;
+
+        // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
+        let mut a = ctx.slice_unsafe(a_ptr, 16);
+        let mut a_clone = a.clone();
+
+        // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 16);
+
+        //for (rot_1, rot_2) in [(R_1, R_2), (R_3, R_4)].into_iter() {
+        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+        for ((v0, v1), m) in a[0..4]
+            .iter_mut()
+            .zip(a_clone[4..8].iter())
+            .zip(b[0..4].iter())
+        {
+            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
+        }
+        a_clone = a.clone();
+
+        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
+            *v3 = (*v3 ^ *v0).rotate_right(R_1);
+        }
+        a_clone = a.clone();
+
+        // v[2] = v[2].wrapping_add(v[3]);
+        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
+            *v2 = (*v2).wrapping_add(*v3);
+        }
+        a_clone = a.clone();
+
+        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
+            *v1 = (*v1 ^ *v2).rotate_right(R_2);
+        }
+        a_clone = a.clone();
+        //}
+
+        ctx.clk += 1;
+
+        // Write rotate_right to a_ptr.
+        let a_reads_writes = ctx.mw_slice(a_ptr, a.as_slice());
+
+        ctx.record_mut()
+            .blake2s_quarter_round_2x_events
+            .push(Blake2sQuarterRound2xEvent {
+                lookup_id,
+                clk: clk_init,
+                shard,
+                channel,
+                a_ptr,
+                b_ptr,
+                a_reads_writes,
+                b_reads,
+            });
+
+        None
+    }
+
+    fn num_extra_cycles(&self) -> u32 {
+        1
+    }
+}
+
+#[derive(Debug, Clone, AlignedBorrow)]
+#[repr(C)]
+struct Blake2sQuarterRound2xCols<T> {
+    pub clk: T,
+    pub shard: T,
+    pub channel: T,
+    pub nonce: T,
+    pub is_real: T,
+
+    pub a_ptr: T,
+    pub b_ptr: T,
+
+    pub a: [MemoryWriteCols<T>; 16],
+    pub b: [MemoryReadCols<T>; 16],
+
+    pub add: [Add4Operation<T>; 8],
+    pub xor: [XorOperation<T>; 8],
+    pub rotate_right: [FixedRotateRightOperation<T>; 8],
+}
+
+impl<T: PrimeField32> BaseAir<T> for Blake2sQuarterRound2xChip {
+    fn width(&self) -> usize {
+        size_of::<Blake2sQuarterRound2xCols<u8>>()
+    }
+}
+
+impl<'a> WithEvents<'a> for Blake2sQuarterRound2xChip {
+    type Events = &'a [Blake2sQuarterRound2xEvent];
+}
+
+impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
+    type Record = ExecutionRecord;
+    type Program = Program;
+
+    fn name(&self) -> String {
+        "Blake2sQuarterRound2xChip".to_string()
+    }
+
+    fn generate_trace<EL: EventLens<Self>>(
+        &self,
+        input: &EL,
+        output: &mut Self::Record,
+    ) -> RowMajorMatrix<F> {
+        let mut rows = vec![];
+        let width = <Blake2sQuarterRound2xChip as BaseAir<F>>::width(self);
+        let mut new_byte_lookup_events = Vec::new();
+        for event in input.events() {
+            let shard = event.shard;
+            let mut row = vec![F::zero(); width];
+            let cols: &mut Blake2sQuarterRound2xCols<F> = row.as_mut_slice().borrow_mut();
+
+            cols.clk = F::from_canonical_u32(event.clk);
+            cols.is_real = F::one();
+            cols.shard = F::from_canonical_u32(event.shard);
+            cols.channel = F::from_canonical_u32(event.channel);
+            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
+            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
+
+            // populate all v, m, 0
+            for i in 0..16usize {
+                cols.a[i].populate(
+                    event.channel,
+                    event.a_reads_writes[i],
+                    &mut new_byte_lookup_events,
+                );
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+            }
+
+            // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
+            // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
+            for i in 0..4usize {
+                // 1x
+                let v0 = event.a_reads_writes[i].value;
+                let v1 = event.a_reads_writes[i + 4].value;
+                let v2 = event.a_reads_writes[i + 8].value;
+                let v3 = event.a_reads_writes[i + 12].value;
+                let m1 = event.b_reads[i].value;
+                //let m2 = event.b_reads[i + 4].value;
+                let zero1 = event.b_reads[i + 8].value;
+                let zero2 = event.b_reads[i + 12].value;
+                assert_eq!(zero1, 0);
+                assert_eq!(zero2, 0);
+
+                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+                let v0_new = cols.add[i].populate(output, shard, event.channel, v0, v1, m1, zero1);
+                assert_eq!(v0 + v1 + m1 + zero1, v0_new);
+
+                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+                let temp = cols.xor[i].populate(output, shard, event.channel, v3, v0);
+                let v3_new =
+                    cols.rotate_right[i].populate(output, shard, event.channel, temp, R_1 as usize);
+                assert_eq!((v3 ^ v0).rotate_right(R_1), v3_new);
+
+                // v[2] = v[2].wrapping_add(v[3]);
+                let v2_new =
+                    cols.add[i + 4].populate(output, shard, event.channel, v2, v3, zero1, zero2);
+                assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
+
+                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+                let temp = cols.xor[i + 4].populate(output, shard, event.channel, v1, v2);
+                let v1_new = cols.rotate_right[i + 4].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_2 as usize,
+                );
+                assert_eq!((v1 ^ v2).rotate_right(R_2), v1_new);
+            }
+
+            /*
+                // 2x
+                let v0 = v0_new;
+                let v1 = v1_new;
+                let v2 = v2_new;
+                let v3 = v3_new;
+
+                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+                let v0_new = cols.add[i + 8].populate(output, shard, event.channel, v0, v1, m2, zero1);
+                assert_eq!(v0 + v1 + m2 + zero1, v0_new);
+
+                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+                let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0);
+                let v3_new = cols.rotate_right[i + 8].populate(output, shard, event.channel, temp, R_3 as usize);
+                assert_eq!((v3 ^ v0).rotate_right(R_3), v3_new);
+
+                // v[2] = v[2].wrapping_add(v[3]);
+                let v2_new = cols.add[i + 12].populate(output, shard, event.channel, v2, v3, zero1, zero2);
+                assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
+
+                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+                let temp = cols.xor[i + 12].populate(output, shard, event.channel, v1, v2);
+                let v1_new = cols.rotate_right[i + 12].populate(output, shard, event.channel, temp, R_4 as usize);
+                assert_eq!((v1 ^ v2).rotate_right(R_4), v1_new);
+            }*/
+
+            rows.push(row);
+        }
+
+        output.add_byte_lookup_events(new_byte_lookup_events);
+
+        pad_rows(&mut rows, || {
+            let row = vec![F::zero(); width];
+
+            row
+        });
+
+        let mut trace =
+            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
+
+        // Write the nonces to the trace.
+        for i in 0..trace.height() {
+            let cols: &mut Blake2sQuarterRound2xCols<F> =
+                trace.values[i * width..(i + 1) * width].borrow_mut();
+            cols.nonce = F::from_canonical_usize(i);
+        }
+
+        trace
+    }
+
+    fn included(&self, shard: &Self::Record) -> bool {
+        !shard.blake2s_quarter_round_2x_events.is_empty()
+    }
+}
+
+impl<AB: SphinxAirBuilder> Air<AB> for Blake2sQuarterRound2xChip
+where
+    AB::F: PrimeField32,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local = main.row_slice(0);
+        let next = main.row_slice(1);
+        let local: &Blake2sQuarterRound2xCols<AB::Var> = (*local).borrow();
+        let next: &Blake2sQuarterRound2xCols<AB::Var> = (*next).borrow();
+
+        // Constrain the incrementing nonce.
+        builder.when_first_row().assert_zero(local.nonce);
+        builder
+            .when_transition()
+            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
+
+        for i in 0..16usize {
+            // Eval a
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
+                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.a[i],
+                local.is_real,
+            );
+
+            // Eval b
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
+        }
+
+        for i in 0..4usize {
+            // 1x
+
+            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+            Add4Operation::<AB::F>::eval(
+                builder,
+                *local.a[i].value(),     // v0
+                *local.a[i + 4].value(), // v1
+                *local.b[i].value(),     // m1
+                *local.b[i + 8].value(), // zero1
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i],
+            );
+
+            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i + 12].value(),
+                *local.a[i].value(),
+                local.xor[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i].value,
+                R_1 as usize,
+                local.rotate_right[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // v[2] = v[2].wrapping_add(v[3]);
+            Add4Operation::<AB::F>::eval(
+                builder,
+                *local.a[i + 8].value(),  // v2
+                *local.a[i + 12].value(), // v3
+                *local.b[i + 8].value(),  // zero1
+                *local.b[i + 12].value(), // zero2
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 4],
+            );
+
+            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i + 4].value(),
+                *local.a[i + 8].value(),
+                local.xor[i + 4],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 4].value,
+                R_2 as usize,
+                local.rotate_right[i + 4],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            /*
+            // 2x
+            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+            Add4Operation::<AB::F>::eval(
+                builder,
+                *local.a[i].value(), // v0
+                *local.a[i + 4].value(), // v1
+                *local.b[i].value(), // m1
+                *local.b[i + 8].value(), // zero1
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i],
+            );
+
+            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i + 12].value(),
+                *local.a[i].value(),
+                local.xor[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i].value,
+                R_1 as usize,
+                local.rotate_right[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // v[2] = v[2].wrapping_add(v[3]);
+            Add4Operation::<AB::F>::eval(
+                builder,
+                *local.a[i + 8].value(), // v2
+                *local.a[i + 12].value(), // v3
+                *local.b[i + 8].value(), // zero1
+                *local.b[i + 12].value(), // zero2
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 4],
+            );
+
+            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i + 4].value(),
+                *local.a[i + 8].value(),
+                local.xor[i + 4],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 4].value,
+                R_2 as usize,
+                local.rotate_right[i + 4],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );*/
+        }
+
+        builder.receive_syscall(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.nonce,
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_QUARTER_ROUND.syscall_id()),
+            local.a_ptr,
+            local.b_ptr,
+            local.is_real,
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::runtime::{Instruction, Opcode, SyscallCode};
+    use crate::utils::tests::BLAKE2S_QUARTER_ROUND_ELF;
+    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
+    use crate::Program;
+
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 16], b: [u32; 16]) -> Program {
+        let mut instructions = vec![];
+        // memory write a
+        for (index, word) in a.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                a_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // memory write b
+        for (index, word) in b.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                b_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // Syscall invocation
+        instructions.push(Instruction::new(
+            Opcode::ADD,
+            5,
+            0,
+            SyscallCode::BLAKE_2S_QUARTER_ROUND as u32,
+            false,
+            true,
+        ));
+        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
+        Program::new(instructions, 0, 0)
+    }
+
+    #[test]
+    fn test_blake2s_quarter_round_precompile() {
+        setup_logger();
+
+        // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
+        // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
+
+        let a_ptr = 100100100;
+        let b_ptr = 200200200;
+        let program = risc_v_program(
+            a_ptr,
+            b_ptr,
+            [
+                0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
+                0x5be0cd19, 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+                0xe07c2654, 0x5be0cd19,
+            ],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        );
+
+        let (_, memory) = run_test_with_memory_inspection(program);
+        let mut result = vec![];
+        // result is 4 words, written to a_ptr
+        for i in 0..16 {
+            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
+        }
+
+        assert_eq!(
+            result,
+            [
+                0xbc1738c6, 0x566d1711, 0x5bf2cd1d, 0x130c253, 0x1ff85cd8, 0x361a0001, 0x6ab383b7,
+                0xd13ef7a9, 0xd4c3d380, 0x3b057bed, 0x27b8af00, 0xb49a500a, 0x6ab9ed19, 0x7f9dcd68,
+                0xeb49bb8e, 0xf4a5ad0,
+            ]
+            .to_vec()
+        );
+    }
+
+    #[test]
+    fn test_blake2s_quarter_round_program() {
+        setup_logger();
+        let program = Program::from(BLAKE2S_QUARTER_ROUND_ELF);
+        run_test(program).unwrap();
+    }
+}
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index 6cfcd9cf4..9b9ba7e2e 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -144,6 +144,9 @@ pub mod tests {
     pub const BLAKE2S_XOR_ROTATE_RIGHT_7_ELF: &[u8] =
         include_bytes!("../../../tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf");
 
+    pub const BLAKE2S_QUARTER_ROUND_ELF: &[u8] =
+        include_bytes!("../../../tests/blake2s-quarter-round/elf/riscv32im-succinct-zkvm-elf");
+
     pub const PANIC_ELF: &[u8] =
         include_bytes!("../../../tests/panic/elf/riscv32im-succinct-zkvm-elf");
 }
diff --git a/tests/blake2s-quarter-round/Cargo.lock b/tests/blake2s-quarter-round/Cargo.lock
new file mode 100644
index 000000000..993d245f6
--- /dev/null
+++ b/tests/blake2s-quarter-round/Cargo.lock
@@ -0,0 +1,539 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2s-quarter_round-test"
+version = "0.1.0"
+dependencies = [
+ "sphinx-zkvm",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest",
+ "elliptic-curve",
+ "rfc6979",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest",
+ "ff",
+ "generic-array",
+ "group",
+ "pkcs8",
+ "rand_core",
+ "sec1",
+ "subtle",
+ "tap",
+ "zeroize",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "bitvec",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core",
+ "subtle",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.2.0-rc.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "once_cell",
+ "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "signature",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "libm"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.210"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest",
+ "rand_core",
+]
+
+[[package]]
+name = "sphinx-precompiles"
+version = "1.0.0"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "hybrid-array",
+ "k256",
+ "serde",
+]
+
+[[package]]
+name = "sphinx-zkvm"
+version = "1.0.0"
+dependencies = [
+ "bincode",
+ "cfg-if",
+ "getrandom",
+ "k256",
+ "lazy_static",
+ "libm",
+ "once_cell",
+ "rand",
+ "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
+ "sphinx-precompiles",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-quarter-round/Cargo.toml b/tests/blake2s-quarter-round/Cargo.toml
new file mode 100644
index 000000000..be741f691
--- /dev/null
+++ b/tests/blake2s-quarter-round/Cargo.toml
@@ -0,0 +1,8 @@
+[workspace]
+[package]
+name = "blake2s-quarter_round-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-quarter-round/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-quarter-round/elf/riscv32im-succinct-zkvm-elf
new file mode 100755
index 0000000000000000000000000000000000000000..917edf787d31e58358ccab560b3a60cce6443e6e
GIT binary patch
literal 25476
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
B+!+7>

literal 0
HcmV?d00001

diff --git a/tests/blake2s-quarter-round/src/main.rs b/tests/blake2s-quarter-round/src/main.rs
new file mode 100644
index 000000000..d9fd8abd3
--- /dev/null
+++ b/tests/blake2s-quarter-round/src/main.rs
@@ -0,0 +1,13 @@
+#![no_main]
+sphinx_zkvm::entrypoint!(main);
+
+use sphinx_zkvm::syscalls::blake2s_quarter_round::syscall_blake2s_quarter_round;
+
+pub fn main() {
+    let mut a: [u32; 16] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+    let b: [u32; 16] = [10, 20, 30, 40, 10, 20, 30, 40, 0, 0, 0, 0, 0, 0, 0, 0];
+
+    syscall_blake2s_quarter_round(a.as_mut_ptr(), b.as_ptr());
+
+    assert_eq!(a, [0x10, 0x1c, 0x28, 0x34, 0xc00000, 0xc00000, 0xc00000, 0x400000, 0x16, 0x18, 0x1a, 0x1c, 0xc0000, 0xc0000, 0xc0000, 0x140000]);
+}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_quarter_round.rs b/zkvm/entrypoint/src/syscalls/blake2s_quarter_round.rs
new file mode 100644
index 000000000..0ff00113b
--- /dev/null
+++ b/zkvm/entrypoint/src/syscalls/blake2s_quarter_round.rs
@@ -0,0 +1,19 @@
+#[cfg(target_os = "zkvm")]
+use core::arch::asm;
+
+#[allow(unused_variables)]
+#[no_mangle]
+pub extern "C" fn syscall_blake2s_quarter_round(left: *mut u32, right: *const u32) {
+    #[cfg(target_os = "zkvm")]
+    unsafe {
+        asm!(
+        "ecall",
+        in("t0") crate::syscalls::BLAKE_2S_QUARTER_ROUND,
+        in("a0") left,
+        in("a1") right
+        );
+    }
+
+    #[cfg(not(target_os = "zkvm"))]
+    unreachable!()
+}
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 2ca7703bd..518870242 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -15,6 +15,7 @@ mod verify;
 
 pub mod blake2s_add_2;
 pub mod blake2s_add_3;
+pub mod blake2s_quarter_round;
 pub mod blake2s_xor_rotate_16;
 pub mod blake2s_xor_rotate_right_12;
 pub mod blake2s_xor_rotate_right_16;
@@ -128,3 +129,5 @@ pub const BLAKE_2S_XOR_ROTATE_RIGHT_12: u32 = 0x00_01_01_EA;
 pub const BLAKE_2S_XOR_ROTATE_RIGHT_8: u32 = 0x00_01_01_EB;
 
 pub const BLAKE_2S_XOR_ROTATE_RIGHT_7: u32 = 0x00_01_01_EC;
+
+pub const BLAKE_2S_QUARTER_ROUND: u32 = 0x00_01_01_ED;
diff --git a/zkvm/precompiles/src/lib.rs b/zkvm/precompiles/src/lib.rs
index a99fa41d8..1c627089a 100644
--- a/zkvm/precompiles/src/lib.rs
+++ b/zkvm/precompiles/src/lib.rs
@@ -48,10 +48,12 @@ extern "C" {
     pub fn syscall_bls12381_g2_add(p: *mut u32, q: *const u32);
     pub fn syscall_bls12381_g2_double(p: *mut u32);
     pub fn syscall_blake2s_xor_rotate_16(w: *mut u32);
+
     pub fn syscall_blake2s_add_2(left: *mut u32, right: *const u32);
     pub fn syscall_blake2s_add_3(left: *mut u32, right: *const u32);
     pub fn syscall_blake2s_xor_rotate_right_16(left: *mut u32, right: *const u32);
     pub fn syscall_blake2s_xor_rotate_right_12(left: *mut u32, right: *const u32);
     pub fn syscall_blake2s_xor_rotate_right_8(left: *mut u32, right: *const u32);
     pub fn syscall_blake2s_xor_rotate_right_7(left: *mut u32, right: *const u32);
+    pub fn syscall_blake2s_quarter_round(left: *mut u32, right: *const u32);
 }

From 462e28e3e6a44a0febbd8c479b9da0aaa8f09ab1 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Wed, 18 Sep 2024 17:22:35 +0300
Subject: [PATCH 16/30] feat: Update quarter_round syscall to quarter_round_2x

---
 core/src/runtime/syscall.rs                   |  13 +-
 core/src/syscall/precompiles/blake2s/mod.rs   |  37 ++++
 .../precompiles/blake2s/quarter_round.rs      | 164 ++++++++++++------
 core/src/utils/programs.rs                    |   4 +-
 .../Cargo.lock                                |   2 +-
 .../Cargo.toml                                |   2 +-
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 0 -> 25436 bytes
 tests/blake2s-quarter-round-2x/src/main.rs    |  22 +++
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25476 -> 0 bytes
 tests/blake2s-quarter-round/src/main.rs       |  13 --
 ...r_round.rs => blake2s_quarter_round_2x.rs} |   4 +-
 zkvm/entrypoint/src/syscalls/mod.rs           |   4 +-
 12 files changed, 182 insertions(+), 83 deletions(-)
 rename tests/{blake2s-quarter-round => blake2s-quarter-round-2x}/Cargo.lock (99%)
 rename tests/{blake2s-quarter-round => blake2s-quarter-round-2x}/Cargo.toml (75%)
 create mode 100755 tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf
 create mode 100644 tests/blake2s-quarter-round-2x/src/main.rs
 delete mode 100755 tests/blake2s-quarter-round/elf/riscv32im-succinct-zkvm-elf
 delete mode 100644 tests/blake2s-quarter-round/src/main.rs
 rename zkvm/entrypoint/src/syscalls/{blake2s_quarter_round.rs => blake2s_quarter_round_2x.rs} (65%)

diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 40c29982a..3d2294103 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -133,7 +133,7 @@ pub enum SyscallCode {
     BLAKE_2S_XOR_ROTATE_RIGHT_12 = 0x00_01_01_EA,
     BLAKE_2S_XOR_ROTATE_RIGHT_8 = 0x00_01_01_EB,
     BLAKE_2S_XOR_ROTATE_RIGHT_7 = 0x00_01_01_EC,
-    BLAKE_2S_QUARTER_ROUND = 0x00_01_01_ED,
+    BLAKE_2S_QUARTER_ROUND_2X = 0x00_01_01_ED,
 }
 
 impl SyscallCode {
@@ -177,7 +177,7 @@ impl SyscallCode {
             0x00_01_01_EA => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12,
             0x00_01_01_EB => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8,
             0x00_01_01_EC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7,
-            0x00_01_01_ED => SyscallCode::BLAKE_2S_QUARTER_ROUND,
+            0x00_01_01_ED => SyscallCode::BLAKE_2S_QUARTER_ROUND_2X,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -452,7 +452,7 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
     );
 
     syscall_map.insert(
-        SyscallCode::BLAKE_2S_QUARTER_ROUND,
+        SyscallCode::BLAKE_2S_QUARTER_ROUND_2X,
         Arc::new(Blake2sQuarterRound2xChip::new()),
     );
 
@@ -610,8 +610,11 @@ mod tests {
                     )
                 }
 
-                SyscallCode::BLAKE_2S_QUARTER_ROUND => {
-                    assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_QUARTER_ROUND)
+                SyscallCode::BLAKE_2S_QUARTER_ROUND_2X => {
+                    assert_eq!(
+                        code as u32,
+                        sphinx_zkvm::syscalls::BLAKE_2S_QUARTER_ROUND_2X
+                    )
                 }
             }
         }
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index efe9f7126..11052054f 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -257,4 +257,41 @@ mod tests {
             vec![0x6ab9ed19, 0x7f9dcd68, 0xeb49bb8e, 0xf4a5ad0]
         );
     }
+
+    #[test]
+    fn test_blake2s_quarter_round_2x_function() {
+        let mut v: Vec<[u32; 4]> = vec![
+            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+            [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0xe07c2654, 0x5be0cd19],
+        ];
+        let m = [0, 0, 0, 0];
+        let rd = 16;
+        let rb = 12;
+
+        quarter_round(&mut v, rd, rb, m);
+
+        let rd = 8;
+        let rb = 7;
+
+        quarter_round(&mut v, rd, rb, m);
+
+        assert_eq!(
+            v[0].to_vec(),
+            vec![0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc]
+        );
+        assert_eq!(
+            v[1].to_vec(),
+            vec![0x408705aa, 0x8d07c52d, 0xb9d6aa3a, 0x88609304]
+        );
+        assert_eq!(
+            v[2].to_vec(),
+            vec![0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed]
+        );
+        assert_eq!(
+            v[3].to_vec(),
+            vec![0x87b6b678, 0x7af31ada, 0x5a2defeb, 0x2cdd25e3]
+        );
+    }
 }
diff --git a/core/src/syscall/precompiles/blake2s/quarter_round.rs b/core/src/syscall/precompiles/blake2s/quarter_round.rs
index c5a5ba86c..e4fb24db7 100644
--- a/core/src/syscall/precompiles/blake2s/quarter_round.rs
+++ b/core/src/syscall/precompiles/blake2s/quarter_round.rs
@@ -20,8 +20,8 @@ use std::mem::size_of;
 
 const R_1: u32 = 16;
 const R_2: u32 = 12;
-//const R_3: u32 = 8;
-//const R_4: u32 = 7;
+const R_3: u32 = 8;
+const R_4: u32 = 7;
 
 #[derive(Default)]
 pub struct Blake2sQuarterRound2xChip;
@@ -62,8 +62,8 @@ impl Syscall for Blake2sQuarterRound2xChip {
         // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
         let (b_reads, b) = ctx.mr_slice(b_ptr, 16);
 
-        //for (rot_1, rot_2) in [(R_1, R_2), (R_3, R_4)].into_iter() {
-        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+        // 1x (m1, R1, R2)
+        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m1)
         for ((v0, v1), m) in a[0..4]
             .iter_mut()
             .zip(a_clone[4..8].iter())
@@ -89,11 +89,39 @@ impl Syscall for Blake2sQuarterRound2xChip {
         for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
             *v1 = (*v1 ^ *v2).rotate_right(R_2);
         }
+
+        // 2x (m2, R3, R4)
+        let mut a = a.clone(); // a after 1x quarter_round
+        let mut a_clone = a.clone();
+
+        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
+        for ((v0, v1), m) in a[0..4]
+            .iter_mut()
+            .zip(a_clone[4..8].iter())
+            .zip(b[4..8].iter())
+        {
+            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
+        }
         a_clone = a.clone();
-        //}
 
-        ctx.clk += 1;
+        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
+            *v3 = (*v3 ^ *v0).rotate_right(R_3);
+        }
+        a_clone = a.clone();
 
+        // v[2] = v[2].wrapping_add(v[3]);
+        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
+            *v2 = (*v2).wrapping_add(*v3);
+        }
+        a_clone = a.clone();
+
+        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
+            *v1 = (*v1 ^ *v2).rotate_right(R_4);
+        }
+
+        ctx.clk += 1;
         // Write rotate_right to a_ptr.
         let a_reads_writes = ctx.mw_slice(a_ptr, a.as_slice());
 
@@ -133,9 +161,9 @@ struct Blake2sQuarterRound2xCols<T> {
     pub a: [MemoryWriteCols<T>; 16],
     pub b: [MemoryReadCols<T>; 16],
 
-    pub add: [Add4Operation<T>; 8],
-    pub xor: [XorOperation<T>; 8],
-    pub rotate_right: [FixedRotateRightOperation<T>; 8],
+    pub add: [Add4Operation<T>; 8 * 2],
+    pub xor: [XorOperation<T>; 8 * 2],
+    pub rotate_right: [FixedRotateRightOperation<T>; 8 * 2],
 }
 
 impl<T: PrimeField32> BaseAir<T> for Blake2sQuarterRound2xChip {
@@ -189,13 +217,13 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
             // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
             // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
             for i in 0..4usize {
-                // 1x
+                // 1x (m1, R1, R2)
                 let v0 = event.a_reads_writes[i].value;
                 let v1 = event.a_reads_writes[i + 4].value;
                 let v2 = event.a_reads_writes[i + 8].value;
                 let v3 = event.a_reads_writes[i + 12].value;
                 let m1 = event.b_reads[i].value;
-                //let m2 = event.b_reads[i + 4].value;
+                let m2 = event.b_reads[i + 4].value;
                 let zero1 = event.b_reads[i + 8].value;
                 let zero2 = event.b_reads[i + 12].value;
                 assert_eq!(zero1, 0);
@@ -226,33 +254,52 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                     R_2 as usize,
                 );
                 assert_eq!((v1 ^ v2).rotate_right(R_2), v1_new);
-            }
 
-            /*
-                // 2x
+                // 2x (m2, R3, R4)
                 let v0 = v0_new;
                 let v1 = v1_new;
                 let v2 = v2_new;
                 let v3 = v3_new;
 
-                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-                let v0_new = cols.add[i + 8].populate(output, shard, event.channel, v0, v1, m2, zero1);
-                assert_eq!(v0 + v1 + m2 + zero1, v0_new);
+                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
+                let v0_new =
+                    cols.add[i + 8].populate(output, shard, event.channel, v0, v1, m2, zero1);
+                assert_eq!(v0 + v1 + m1 + zero1, v0_new);
 
-                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
                 let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0);
-                let v3_new = cols.rotate_right[i + 8].populate(output, shard, event.channel, temp, R_3 as usize);
+                let v3_new = cols.rotate_right[i + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_3 as usize,
+                );
                 assert_eq!((v3 ^ v0).rotate_right(R_3), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                let v2_new = cols.add[i + 12].populate(output, shard, event.channel, v2, v3, zero1, zero2);
+                let v2_new = cols.add[i + 4 + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    v2,
+                    v3,
+                    zero1,
+                    zero2,
+                );
                 assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
 
-                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-                let temp = cols.xor[i + 12].populate(output, shard, event.channel, v1, v2);
-                let v1_new = cols.rotate_right[i + 12].populate(output, shard, event.channel, temp, R_4 as usize);
+                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
+                let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2);
+                let v1_new = cols.rotate_right[i + 4 + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_4 as usize,
+                );
                 assert_eq!((v1 ^ v2).rotate_right(R_4), v1_new);
-            }*/
+            }
 
             rows.push(row);
         }
@@ -384,6 +431,7 @@ where
                 &local.channel,
                 local.is_real,
             );
+
             // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
@@ -395,38 +443,39 @@ where
                 local.is_real,
             );
 
-            /*
             // 2x
+
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
                 builder,
-                *local.a[i].value(), // v0
-                *local.a[i + 4].value(), // v1
-                *local.b[i].value(), // m1
-                *local.b[i + 8].value(), // zero1
+                local.add[i].value,              // v0 after 1x
+                local.rotate_right[i + 4].value, // v1 after 1x
+                *local.b[i + 4].value(),         // m2
+                *local.b[i + 8].value(),         // zero1
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[i],
+                local.add[i + 8],
             );
 
             // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
             // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
-                *local.a[i + 12].value(),
-                *local.a[i].value(),
-                local.xor[i],
+                local.rotate_right[i].value, // v3 after 1x
+                local.add[i].value,          // v0 after 1x
+                local.xor[i + 8],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
+
             // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
-                local.xor[i].value,
-                R_1 as usize,
-                local.rotate_right[i],
+                local.xor[i + 8].value,
+                R_3 as usize,
+                local.rotate_right[i + 8],
                 local.shard,
                 &local.channel,
                 local.is_real,
@@ -435,37 +484,38 @@ where
             // v[2] = v[2].wrapping_add(v[3]);
             Add4Operation::<AB::F>::eval(
                 builder,
-                *local.a[i + 8].value(), // v2
-                *local.a[i + 12].value(), // v3
-                *local.b[i + 8].value(), // zero1
-                *local.b[i + 12].value(), // zero2
+                local.add[i + 4].value,      // v2 after 1x
+                local.rotate_right[i].value, // v3 after 1x
+                *local.b[i + 8].value(),     // zero1
+                *local.b[i + 12].value(),    // zero2
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[i + 4],
+                local.add[i + 12],
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
             // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
-                *local.a[i + 4].value(),
-                *local.a[i + 8].value(),
-                local.xor[i + 4],
+                local.rotate_right[i + 4].value, // v1 after 1x
+                local.add[i + 4].value,          // v2 after 1x
+                local.xor[i + 12],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
+
             // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
-                local.xor[i + 4].value,
-                R_2 as usize,
-                local.rotate_right[i + 4],
+                local.xor[i + 12].value,
+                R_4 as usize,
+                local.rotate_right[i + 12],
                 local.shard,
                 &local.channel,
                 local.is_real,
-            );*/
+            );
         }
 
         builder.receive_syscall(
@@ -473,7 +523,7 @@ where
             local.channel,
             local.clk,
             local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_QUARTER_ROUND.syscall_id()),
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_QUARTER_ROUND_2X.syscall_id()),
             local.a_ptr,
             local.b_ptr,
             local.is_real,
@@ -484,7 +534,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::BLAKE2S_QUARTER_ROUND_ELF;
+    use crate::utils::tests::BLAKE2S_QUARTER_ROUND_2X_ELF;
     use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
@@ -523,7 +573,7 @@ mod tests {
             Opcode::ADD,
             5,
             0,
-            SyscallCode::BLAKE_2S_QUARTER_ROUND as u32,
+            SyscallCode::BLAKE_2S_QUARTER_ROUND_2X as u32,
             false,
             true,
         ));
@@ -534,7 +584,7 @@ mod tests {
     }
 
     #[test]
-    fn test_blake2s_quarter_round_precompile() {
+    fn test_blake2s_quarter_round_2x_precompile() {
         setup_logger();
 
         // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
@@ -563,18 +613,18 @@ mod tests {
         assert_eq!(
             result,
             [
-                0xbc1738c6, 0x566d1711, 0x5bf2cd1d, 0x130c253, 0x1ff85cd8, 0x361a0001, 0x6ab383b7,
-                0xd13ef7a9, 0xd4c3d380, 0x3b057bed, 0x27b8af00, 0xb49a500a, 0x6ab9ed19, 0x7f9dcd68,
-                0xeb49bb8e, 0xf4a5ad0,
+                0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x408705aa, 0x8d07c52d, 0xb9d6aa3a,
+                0x88609304, 0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed, 0x87b6b678, 0x7af31ada,
+                0x5a2defeb, 0x2cdd25e3,
             ]
             .to_vec()
         );
     }
 
     #[test]
-    fn test_blake2s_quarter_round_program() {
+    fn test_blake2s_quarter_round_2x_program() {
         setup_logger();
-        let program = Program::from(BLAKE2S_QUARTER_ROUND_ELF);
+        let program = Program::from(BLAKE2S_QUARTER_ROUND_2X_ELF);
         run_test(program).unwrap();
     }
 }
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index 9b9ba7e2e..ae2a8665d 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -144,8 +144,8 @@ pub mod tests {
     pub const BLAKE2S_XOR_ROTATE_RIGHT_7_ELF: &[u8] =
         include_bytes!("../../../tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf");
 
-    pub const BLAKE2S_QUARTER_ROUND_ELF: &[u8] =
-        include_bytes!("../../../tests/blake2s-quarter-round/elf/riscv32im-succinct-zkvm-elf");
+    pub const BLAKE2S_QUARTER_ROUND_2X_ELF: &[u8] =
+        include_bytes!("../../../tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf");
 
     pub const PANIC_ELF: &[u8] =
         include_bytes!("../../../tests/panic/elf/riscv32im-succinct-zkvm-elf");
diff --git a/tests/blake2s-quarter-round/Cargo.lock b/tests/blake2s-quarter-round-2x/Cargo.lock
similarity index 99%
rename from tests/blake2s-quarter-round/Cargo.lock
rename to tests/blake2s-quarter-round-2x/Cargo.lock
index 993d245f6..7efd0650c 100644
--- a/tests/blake2s-quarter-round/Cargo.lock
+++ b/tests/blake2s-quarter-round-2x/Cargo.lock
@@ -42,7 +42,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "blake2s-quarter_round-test"
+name = "blake2s-quarter_round-2x-test"
 version = "0.1.0"
 dependencies = [
  "sphinx-zkvm",
diff --git a/tests/blake2s-quarter-round/Cargo.toml b/tests/blake2s-quarter-round-2x/Cargo.toml
similarity index 75%
rename from tests/blake2s-quarter-round/Cargo.toml
rename to tests/blake2s-quarter-round-2x/Cargo.toml
index be741f691..188c60950 100644
--- a/tests/blake2s-quarter-round/Cargo.toml
+++ b/tests/blake2s-quarter-round-2x/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace]
 [package]
-name = "blake2s-quarter_round-test"
+name = "blake2s-quarter_round-2x-test"
 version = "0.1.0"
 edition = "2021"
 
diff --git a/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf
new file mode 100755
index 0000000000000000000000000000000000000000..98d15aac574510f6ef7609aaaf412514415e8982
GIT binary patch
literal 25436
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
Q-jcujP!6IQ{Uyu&KRV(6J^%m!

literal 0
HcmV?d00001

diff --git a/tests/blake2s-quarter-round-2x/src/main.rs b/tests/blake2s-quarter-round-2x/src/main.rs
new file mode 100644
index 000000000..9b98e8d17
--- /dev/null
+++ b/tests/blake2s-quarter-round-2x/src/main.rs
@@ -0,0 +1,22 @@
+#![no_main]
+sphinx_zkvm::entrypoint!(main);
+
+use sphinx_zkvm::syscalls::blake2s_quarter_round_2x::syscall_blake2s_quarter_round_2x;
+
+pub fn main() {
+    let mut a: [u32; 16] = [
+        0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
+        0x5be0cd19, 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+        0xe07c2654, 0x5be0cd19
+    ];
+    let b: [u32; 16] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+    syscall_blake2s_quarter_round_2x(a.as_mut_ptr(), b.as_ptr());
+
+    assert_eq!(a, [
+        0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc,
+        0x408705aa, 0x8d07c52d, 0xb9d6aa3a, 0x88609304,
+        0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed,
+        0x87b6b678, 0x7af31ada, 0x5a2defeb, 0x2cdd25e3
+    ]);
+}
diff --git a/tests/blake2s-quarter-round/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-quarter-round/elf/riscv32im-succinct-zkvm-elf
deleted file mode 100755
index 917edf787d31e58358ccab560b3a60cce6443e6e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 25476
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
B+!+7>

diff --git a/tests/blake2s-quarter-round/src/main.rs b/tests/blake2s-quarter-round/src/main.rs
deleted file mode 100644
index d9fd8abd3..000000000
--- a/tests/blake2s-quarter-round/src/main.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![no_main]
-sphinx_zkvm::entrypoint!(main);
-
-use sphinx_zkvm::syscalls::blake2s_quarter_round::syscall_blake2s_quarter_round;
-
-pub fn main() {
-    let mut a: [u32; 16] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
-    let b: [u32; 16] = [10, 20, 30, 40, 10, 20, 30, 40, 0, 0, 0, 0, 0, 0, 0, 0];
-
-    syscall_blake2s_quarter_round(a.as_mut_ptr(), b.as_ptr());
-
-    assert_eq!(a, [0x10, 0x1c, 0x28, 0x34, 0xc00000, 0xc00000, 0xc00000, 0x400000, 0x16, 0x18, 0x1a, 0x1c, 0xc0000, 0xc0000, 0xc0000, 0x140000]);
-}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_quarter_round.rs b/zkvm/entrypoint/src/syscalls/blake2s_quarter_round_2x.rs
similarity index 65%
rename from zkvm/entrypoint/src/syscalls/blake2s_quarter_round.rs
rename to zkvm/entrypoint/src/syscalls/blake2s_quarter_round_2x.rs
index 0ff00113b..358e9615c 100644
--- a/zkvm/entrypoint/src/syscalls/blake2s_quarter_round.rs
+++ b/zkvm/entrypoint/src/syscalls/blake2s_quarter_round_2x.rs
@@ -3,12 +3,12 @@ use core::arch::asm;
 
 #[allow(unused_variables)]
 #[no_mangle]
-pub extern "C" fn syscall_blake2s_quarter_round(left: *mut u32, right: *const u32) {
+pub extern "C" fn syscall_blake2s_quarter_round_2x(left: *mut u32, right: *const u32) {
     #[cfg(target_os = "zkvm")]
     unsafe {
         asm!(
         "ecall",
-        in("t0") crate::syscalls::BLAKE_2S_QUARTER_ROUND,
+        in("t0") crate::syscalls::BLAKE_2S_QUARTER_ROUND_2X,
         in("a0") left,
         in("a1") right
         );
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 518870242..2d1c8b0a7 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -15,7 +15,7 @@ mod verify;
 
 pub mod blake2s_add_2;
 pub mod blake2s_add_3;
-pub mod blake2s_quarter_round;
+pub mod blake2s_quarter_round_2x;
 pub mod blake2s_xor_rotate_16;
 pub mod blake2s_xor_rotate_right_12;
 pub mod blake2s_xor_rotate_right_16;
@@ -130,4 +130,4 @@ pub const BLAKE_2S_XOR_ROTATE_RIGHT_8: u32 = 0x00_01_01_EB;
 
 pub const BLAKE_2S_XOR_ROTATE_RIGHT_7: u32 = 0x00_01_01_EC;
 
-pub const BLAKE_2S_QUARTER_ROUND: u32 = 0x00_01_01_ED;
+pub const BLAKE_2S_QUARTER_ROUND_2X: u32 = 0x00_01_01_ED;

From 72a44ac1f97ace9ded4c66681263743e216b90ef Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Wed, 18 Sep 2024 20:56:58 +0300
Subject: [PATCH 17/30] feat: Add shuffle operation/constraints to
 quarter_round_2x chip

---
 core/src/syscall/precompiles/blake2s/mod.rs   |  38 ++++++++++
 .../precompiles/blake2s/quarter_round.rs      |  65 +++++++++++++++---
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25436 -> 25436 bytes
 tests/blake2s-quarter-round-2x/src/main.rs    |   6 +-
 4 files changed, 97 insertions(+), 12 deletions(-)

diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 11052054f..a747c83ef 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -294,4 +294,42 @@ mod tests {
             vec![0x87b6b678, 0x7af31ada, 0x5a2defeb, 0x2cdd25e3]
         );
     }
+
+    #[test]
+    fn test_blake2s_quarter_round_2x_shuffle_function() {
+        let mut v: Vec<[u32; 4]> = vec![
+            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+            [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0xe07c2654, 0x5be0cd19],
+        ];
+        let m = [0, 0, 0, 0];
+        let rd = 16;
+        let rb = 12;
+
+        quarter_round(&mut v, rd, rb, m);
+
+        let rd = 8;
+        let rb = 7;
+
+        quarter_round(&mut v, rd, rb, m);
+        shuffle(&mut v);
+
+        assert_eq!(
+            v[0].to_vec(),
+            vec![0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc]
+        );
+        assert_eq!(
+            v[1].to_vec(),
+            vec![0x8d07c52d, 0xb9d6aa3a, 0x88609304, 0x408705aa]
+        );
+        assert_eq!(
+            v[2].to_vec(),
+            vec![0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7]
+        );
+        assert_eq!(
+            v[3].to_vec(),
+            vec![0x2cdd25e3, 0x87b6b678, 0x7af31ada, 0x5a2defeb]
+        );
+    }
 }
diff --git a/core/src/syscall/precompiles/blake2s/quarter_round.rs b/core/src/syscall/precompiles/blake2s/quarter_round.rs
index e4fb24db7..c463e7869 100644
--- a/core/src/syscall/precompiles/blake2s/quarter_round.rs
+++ b/core/src/syscall/precompiles/blake2s/quarter_round.rs
@@ -30,6 +30,23 @@ impl Blake2sQuarterRound2xChip {
     pub fn new() -> Self {
         Blake2sQuarterRound2xChip
     }
+    pub fn constrain_shuffled_indices<AB: SphinxAirBuilder>(
+        &self,
+        builder: &mut AB,
+        shuffled_indices: &[AB::Var],
+        is_real: AB::Var,
+    ) {
+        for index in 0..4 {
+            builder
+                .when(is_real)
+                .assert_eq(shuffled_indices[index], AB::F::from_canonical_usize(0));
+        }
+        for index in 4..shuffled_indices.len() {
+            builder
+                .when(is_real)
+                .assert_eq(shuffled_indices[index], AB::F::from_canonical_usize(1));
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -121,6 +138,21 @@ impl Syscall for Blake2sQuarterRound2xChip {
             *v1 = (*v1 ^ *v2).rotate_right(R_4);
         }
 
+        // shuffle
+        // v[1]
+        a[4..8].swap(0, 3);
+        a[4..8].swap(0, 1);
+        a[4..8].swap(1, 2);
+
+        // v[2]
+        a[8..12].swap(0, 2);
+        a[8..12].swap(1, 3);
+
+        // v[3]
+        a[12..16].swap(2, 3);
+        a[12..16].swap(1, 2);
+        a[12..16].swap(0, 1);
+
         ctx.clk += 1;
         // Write rotate_right to a_ptr.
         let a_reads_writes = ctx.mw_slice(a_ptr, a.as_slice());
@@ -158,6 +190,8 @@ struct Blake2sQuarterRound2xCols<T> {
     pub a_ptr: T,
     pub b_ptr: T,
 
+    pub shuffled_indices: [T; 16],
+
     pub a: [MemoryWriteCols<T>; 16],
     pub b: [MemoryReadCols<T>; 16],
 
@@ -214,6 +248,10 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
             }
 
+            let v1_shuffle_lookup = vec![1, 2, 3, 0];
+            let v2_shuffle_lookup = vec![2, 3, 0, 1];
+            let v3_shuffle_lookup = vec![3, 0, 1, 2];
+
             // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
             // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
             for i in 0..4usize {
@@ -267,8 +305,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 assert_eq!(v0 + v1 + m1 + zero1, v0_new);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
+                cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0);
-                let v3_new = cols.rotate_right[i + 8].populate(
+                let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -278,7 +317,8 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 assert_eq!((v3 ^ v0).rotate_right(R_3), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                let v2_new = cols.add[i + 4 + 8].populate(
+                cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
+                let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -290,8 +330,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
+                cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2);
-                let v1_new = cols.rotate_right[i + 4 + 8].populate(
+                let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -445,6 +486,10 @@ where
 
             // 2x
 
+            let v1_shuffle_lookup = vec![1, 2, 3, 0];
+            let v2_shuffle_lookup = vec![2, 3, 0, 1];
+            let v3_shuffle_lookup = vec![3, 0, 1, 2];
+
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
                 builder,
@@ -475,7 +520,7 @@ where
                 builder,
                 local.xor[i + 8].value,
                 R_3 as usize,
-                local.rotate_right[i + 8],
+                local.rotate_right[v3_shuffle_lookup[i] + 8],
                 local.shard,
                 &local.channel,
                 local.is_real,
@@ -491,7 +536,7 @@ where
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[i + 12],
+                local.add[v2_shuffle_lookup[i] + 12],
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
@@ -511,13 +556,15 @@ where
                 builder,
                 local.xor[i + 12].value,
                 R_4 as usize,
-                local.rotate_right[i + 12],
+                local.rotate_right[v1_shuffle_lookup[i] + 12],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
         }
 
+        self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
+
         builder.receive_syscall(
             local.shard,
             local.channel,
@@ -613,9 +660,9 @@ mod tests {
         assert_eq!(
             result,
             [
-                0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x408705aa, 0x8d07c52d, 0xb9d6aa3a,
-                0x88609304, 0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed, 0x87b6b678, 0x7af31ada,
-                0x5a2defeb, 0x2cdd25e3,
+                0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x8d07c52d, 0xb9d6aa3a, 0x88609304,
+                0x408705aa, 0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7, 0x2cdd25e3, 0x87b6b678,
+                0x7af31ada, 0x5a2defeb
             ]
             .to_vec()
         );
diff --git a/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf
index 98d15aac574510f6ef7609aaaf412514415e8982..578cb1e8ed2114273c8e265dc27da0db9b2017af 100755
GIT binary patch
delta 63
zcmV-F0Kos;#sS>M0kEi0FfGLgjXJ8<xdfA7h^hsLK<l37f$ep7;rNMqT*sF9wc{n-
VEO@rIhuRwRdh72kTC><tgc3OOBF6v#

delta 63
zcmV-F0Kos;#sS>M0kEi0FscQIKrO`wjXJ8<xdfA7i1>+mT*sF9wd<bdf$ep7;dr*T
VhuRwRdh72kTH__%EVI~9gc3G8BF6v#

diff --git a/tests/blake2s-quarter-round-2x/src/main.rs b/tests/blake2s-quarter-round-2x/src/main.rs
index 9b98e8d17..bbdfa8933 100644
--- a/tests/blake2s-quarter-round-2x/src/main.rs
+++ b/tests/blake2s-quarter-round-2x/src/main.rs
@@ -15,8 +15,8 @@ pub fn main() {
 
     assert_eq!(a, [
         0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc,
-        0x408705aa, 0x8d07c52d, 0xb9d6aa3a, 0x88609304,
-        0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed,
-        0x87b6b678, 0x7af31ada, 0x5a2defeb, 0x2cdd25e3
+        0x8d07c52d, 0xb9d6aa3a, 0x88609304, 0x408705aa,
+        0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7,
+        0x2cdd25e3, 0x87b6b678, 0x7af31ada, 0x5a2defeb
     ]);
 }

From 5535a8224deb4ac8df44f3d1033973c4c4384026 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Thu, 19 Sep 2024 13:53:03 +0300
Subject: [PATCH 18/30] chore: Don't update hybryd-array dependency

---
 Cargo.lock | 36 ++++++++++++++++++------------------
 Cargo.toml |  2 +-
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 48201fb87..fcf5f2030 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -248,9 +248,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.88"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e1496f8fb1fbf272686b8d37f523dab3e4a7443300055e74cdaa449f3114356"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
 dependencies = [
  "backtrace",
 ]
@@ -381,9 +381,9 @@ dependencies = [
 
 [[package]]
 name = "arrayref"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d151e35f61089500b617991b791fc8bfd237ae50cd5950803758a179b41e67a"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
 [[package]]
 name = "arrayvec"
@@ -714,9 +714,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.7.1"
+version = "1.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50"
+checksum = "428d9aa8fbc0670b7b8d6030a7fadd0f86151cae55e4dbbece15f3780a3dfaf3"
 dependencies = [
  "serde",
 ]
@@ -761,9 +761,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.1.18"
+version = "1.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b62ac837cdb5cb22e10a256099b4fc502b1dfe560cb282963a974d7abd80e476"
+checksum = "07b1695e2c7e8fc85310cde85aeaab7e3097f593c91d209d3f9df76c928100f0"
 dependencies = [
  "jobserver",
  "libc",
@@ -2228,9 +2228,9 @@ dependencies = [
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.60"
+version = "0.1.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
@@ -3410,7 +3410,7 @@ version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ecf48c7ca261d60b74ab1a7b20da18bede46776b2e55535cb958eb595c5fa7b"
 dependencies = [
- "toml_edit 0.22.20",
+ "toml_edit 0.22.21",
 ]
 
 [[package]]
@@ -5105,7 +5105,7 @@ dependencies = [
  "serde",
  "serde_spanned",
  "toml_datetime",
- "toml_edit 0.22.20",
+ "toml_edit 0.22.21",
 ]
 
 [[package]]
@@ -5130,9 +5130,9 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.22.20"
+version = "0.22.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "583c44c02ad26b0c3f3066fe629275e50627026c51ac2e595cca4c230ce1ce1d"
+checksum = "3b072cee73c449a636ffd6f32bd8de3a9f7119139aff882f44943ce2986dc5cf"
 dependencies = [
  "indexmap 2.5.0",
  "serde",
@@ -5341,9 +5341,9 @@ checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.23"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
+checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
 dependencies = [
  "tinyvec",
 ]
@@ -5566,9 +5566,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-roots"
-version = "0.26.5"
+version = "0.26.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bd24728e5af82c6c4ec1b66ac4844bdf8156257fccda846ec58b42cd0cdbe6a"
+checksum = "841c67bff177718f1d4dfefde8d8f0e78f9b6589319ba88312f567fc5841a958"
 dependencies = [
  "rustls-pki-types",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 274f79a71..c8a8085d6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -78,7 +78,7 @@ getrandom = "=0.2.14" # 0.2.15 depends on yanked libc 0.2.154
 hashbrown = { version = "0.14.5", features = ["serde"] }
 hex = "0.4.3"
 home = "0.5.9"
-hybrid-array = "0.2.0-rc"
+hybrid-array = "0.2.0-rc.9"
 indicatif = "0.17.8"
 itertools = "0.12.1"
 k256 = "0.13.3"

From 096e4d0f8d62d28c9e16e99d33f36b413d507d56 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Thu, 19 Sep 2024 14:10:57 +0300
Subject: [PATCH 19/30] chore: Revert shuffling

---
 .../precompiles/blake2s/quarter_round.rs      |  59 +++++++++++-------
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25436 -> 25436 bytes
 tests/blake2s-quarter-round-2x/src/main.rs    |   9 ++-
 3 files changed, 45 insertions(+), 23 deletions(-)

diff --git a/core/src/syscall/precompiles/blake2s/quarter_round.rs b/core/src/syscall/precompiles/blake2s/quarter_round.rs
index c463e7869..0b50a487c 100644
--- a/core/src/syscall/precompiles/blake2s/quarter_round.rs
+++ b/core/src/syscall/precompiles/blake2s/quarter_round.rs
@@ -140,18 +140,18 @@ impl Syscall for Blake2sQuarterRound2xChip {
 
         // shuffle
         // v[1]
-        a[4..8].swap(0, 3);
-        a[4..8].swap(0, 1);
-        a[4..8].swap(1, 2);
+        //a[4..8].swap(0, 3);
+        //a[4..8].swap(0, 1);
+        //a[4..8].swap(1, 2);
 
         // v[2]
-        a[8..12].swap(0, 2);
-        a[8..12].swap(1, 3);
+        //a[8..12].swap(0, 2);
+        //a[8..12].swap(1, 3);
 
         // v[3]
-        a[12..16].swap(2, 3);
-        a[12..16].swap(1, 2);
-        a[12..16].swap(0, 1);
+        //a[12..16].swap(2, 3);
+        //a[12..16].swap(1, 2);
+        //a[12..16].swap(0, 1);
 
         ctx.clk += 1;
         // Write rotate_right to a_ptr.
@@ -248,9 +248,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
             }
 
-            let v1_shuffle_lookup = vec![1, 2, 3, 0];
-            let v2_shuffle_lookup = vec![2, 3, 0, 1];
-            let v3_shuffle_lookup = vec![3, 0, 1, 2];
+            //let v1_shuffle_lookup = vec![1, 2, 3, 0];
+            //let v2_shuffle_lookup = vec![2, 3, 0, 1];
+            //let v3_shuffle_lookup = vec![3, 0, 1, 2];
 
             // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
             // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
@@ -307,7 +307,8 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
                 cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0);
-                let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
+                //let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
+                let v3_new = cols.rotate_right[i + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -318,7 +319,8 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
 
                 // v[2] = v[2].wrapping_add(v[3]);
                 cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
-                let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
+                //let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
+                let v2_new = cols.add[i + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -332,7 +334,8 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
                 cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2);
-                let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
+                //let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
+                let v1_new = cols.rotate_right[i + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -486,9 +489,9 @@ where
 
             // 2x
 
-            let v1_shuffle_lookup = vec![1, 2, 3, 0];
-            let v2_shuffle_lookup = vec![2, 3, 0, 1];
-            let v3_shuffle_lookup = vec![3, 0, 1, 2];
+            //let v1_shuffle_lookup = vec![1, 2, 3, 0];
+            //let v2_shuffle_lookup = vec![2, 3, 0, 1];
+            //let v3_shuffle_lookup = vec![3, 0, 1, 2];
 
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
@@ -520,7 +523,8 @@ where
                 builder,
                 local.xor[i + 8].value,
                 R_3 as usize,
-                local.rotate_right[v3_shuffle_lookup[i] + 8],
+                //local.rotate_right[v3_shuffle_lookup[i] + 8],
+                local.rotate_right[i + 8],
                 local.shard,
                 &local.channel,
                 local.is_real,
@@ -536,7 +540,8 @@ where
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[v2_shuffle_lookup[i] + 12],
+                //local.add[v2_shuffle_lookup[i] + 12],
+                local.add[i + 12],
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
@@ -556,14 +561,15 @@ where
                 builder,
                 local.xor[i + 12].value,
                 R_4 as usize,
-                local.rotate_right[v1_shuffle_lookup[i] + 12],
+                //local.rotate_right[v1_shuffle_lookup[i] + 12],
+                local.rotate_right[i + 12],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
         }
 
-        self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
+        //self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
 
         builder.receive_syscall(
             local.shard,
@@ -658,6 +664,15 @@ mod tests {
         }
 
         assert_eq!(
+            result,
+            [
+                0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x408705aa, 0x8d07c52d, 0xb9d6aa3a,
+                0x88609304, 0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed, 0x87b6b678, 0x7af31ada,
+                0x5a2defeb, 0x2cdd25e3,
+            ]
+        );
+
+        /*assert_eq!(
             result,
             [
                 0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x8d07c52d, 0xb9d6aa3a, 0x88609304,
@@ -665,7 +680,7 @@ mod tests {
                 0x7af31ada, 0x5a2defeb
             ]
             .to_vec()
-        );
+        );*/
     }
 
     #[test]
diff --git a/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf
index 578cb1e8ed2114273c8e265dc27da0db9b2017af..98d15aac574510f6ef7609aaaf412514415e8982 100755
GIT binary patch
delta 63
zcmV-F0Kos;#sS>M0kEi0FscQIKrO`wjXJ8<xdfA7i1>+mT*sF9wd<bdf$ep7;dr*T
VhuRwRdh72kTH__%EVI~9gc3G8BF6v#

delta 63
zcmV-F0Kos;#sS>M0kEi0FfGLgjXJ8<xdfA7h^hsLK<l37f$ep7;rNMqT*sF9wc{n-
VEO@rIhuRwRdh72kTC><tgc3OOBF6v#

diff --git a/tests/blake2s-quarter-round-2x/src/main.rs b/tests/blake2s-quarter-round-2x/src/main.rs
index bbdfa8933..70fb9f6bd 100644
--- a/tests/blake2s-quarter-round-2x/src/main.rs
+++ b/tests/blake2s-quarter-round-2x/src/main.rs
@@ -13,10 +13,17 @@ pub fn main() {
 
     syscall_blake2s_quarter_round_2x(a.as_mut_ptr(), b.as_ptr());
 
+    assert_eq!(a, [
+        0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x408705aa, 0x8d07c52d, 0xb9d6aa3a,
+        0x88609304, 0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed, 0x87b6b678, 0x7af31ada,
+        0x5a2defeb, 0x2cdd25e3,
+    ]);
+
+    /*
     assert_eq!(a, [
         0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc,
         0x8d07c52d, 0xb9d6aa3a, 0x88609304, 0x408705aa,
         0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7,
         0x2cdd25e3, 0x87b6b678, 0x7af31ada, 0x5a2defeb
-    ]);
+    ]);*/
 }

From 26c0b668e9d42fdbdfd31386f535035954179254 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Thu, 19 Sep 2024 14:23:47 +0300
Subject: [PATCH 20/30] chore: Return shuffling

---
 .../precompiles/blake2s/quarter_round.rs      |  61 +++++++++---------
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25436 -> 25436 bytes
 tests/blake2s-quarter-round-2x/src/main.rs    |   7 +-
 3 files changed, 35 insertions(+), 33 deletions(-)

diff --git a/core/src/syscall/precompiles/blake2s/quarter_round.rs b/core/src/syscall/precompiles/blake2s/quarter_round.rs
index 0b50a487c..563b2c0c5 100644
--- a/core/src/syscall/precompiles/blake2s/quarter_round.rs
+++ b/core/src/syscall/precompiles/blake2s/quarter_round.rs
@@ -140,18 +140,18 @@ impl Syscall for Blake2sQuarterRound2xChip {
 
         // shuffle
         // v[1]
-        //a[4..8].swap(0, 3);
-        //a[4..8].swap(0, 1);
-        //a[4..8].swap(1, 2);
+        a[4..8].swap(0, 3);
+        a[4..8].swap(0, 1);
+        a[4..8].swap(1, 2);
 
         // v[2]
-        //a[8..12].swap(0, 2);
-        //a[8..12].swap(1, 3);
+        a[8..12].swap(0, 2);
+        a[8..12].swap(1, 3);
 
         // v[3]
-        //a[12..16].swap(2, 3);
-        //a[12..16].swap(1, 2);
-        //a[12..16].swap(0, 1);
+        a[12..16].swap(2, 3);
+        a[12..16].swap(1, 2);
+        a[12..16].swap(0, 1);
 
         ctx.clk += 1;
         // Write rotate_right to a_ptr.
@@ -248,9 +248,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
             }
 
-            //let v1_shuffle_lookup = vec![1, 2, 3, 0];
-            //let v2_shuffle_lookup = vec![2, 3, 0, 1];
-            //let v3_shuffle_lookup = vec![3, 0, 1, 2];
+            let v1_shuffle_lookup = vec![1, 2, 3, 0];
+            let v2_shuffle_lookup = vec![2, 3, 0, 1];
+            let v3_shuffle_lookup = vec![3, 0, 1, 2];
 
             // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
             // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
@@ -307,8 +307,8 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
                 cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0);
-                //let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
-                let v3_new = cols.rotate_right[i + 8].populate(
+                let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
+                //let v3_new = cols.rotate_right[i + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -319,8 +319,8 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
 
                 // v[2] = v[2].wrapping_add(v[3]);
                 cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
-                //let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
-                let v2_new = cols.add[i + 4 + 8].populate(
+                let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
+                //let v2_new = cols.add[i + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -334,8 +334,8 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
                 cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2);
-                //let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
-                let v1_new = cols.rotate_right[i + 4 + 8].populate(
+                let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
+                //let v1_new = cols.rotate_right[i + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -489,9 +489,9 @@ where
 
             // 2x
 
-            //let v1_shuffle_lookup = vec![1, 2, 3, 0];
-            //let v2_shuffle_lookup = vec![2, 3, 0, 1];
-            //let v3_shuffle_lookup = vec![3, 0, 1, 2];
+            let v1_shuffle_lookup = vec![1, 2, 3, 0];
+            let v2_shuffle_lookup = vec![2, 3, 0, 1];
+            let v3_shuffle_lookup = vec![3, 0, 1, 2];
 
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
@@ -523,8 +523,8 @@ where
                 builder,
                 local.xor[i + 8].value,
                 R_3 as usize,
-                //local.rotate_right[v3_shuffle_lookup[i] + 8],
-                local.rotate_right[i + 8],
+                local.rotate_right[v3_shuffle_lookup[i] + 8],
+                //local.rotate_right[i + 8],
                 local.shard,
                 &local.channel,
                 local.is_real,
@@ -540,8 +540,8 @@ where
                 local.shard,
                 local.channel,
                 local.is_real,
-                //local.add[v2_shuffle_lookup[i] + 12],
-                local.add[i + 12],
+                local.add[v2_shuffle_lookup[i] + 12],
+                //local.add[i + 12],
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
@@ -561,15 +561,15 @@ where
                 builder,
                 local.xor[i + 12].value,
                 R_4 as usize,
-                //local.rotate_right[v1_shuffle_lookup[i] + 12],
-                local.rotate_right[i + 12],
+                local.rotate_right[v1_shuffle_lookup[i] + 12],
+                //local.rotate_right[i + 12],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
         }
 
-        //self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
+        self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
 
         builder.receive_syscall(
             local.shard,
@@ -663,6 +663,7 @@ mod tests {
             result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
         }
 
+        /*
         assert_eq!(
             result,
             [
@@ -670,9 +671,9 @@ mod tests {
                 0x88609304, 0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed, 0x87b6b678, 0x7af31ada,
                 0x5a2defeb, 0x2cdd25e3,
             ]
-        );
+        );*/
 
-        /*assert_eq!(
+        assert_eq!(
             result,
             [
                 0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x8d07c52d, 0xb9d6aa3a, 0x88609304,
@@ -680,7 +681,7 @@ mod tests {
                 0x7af31ada, 0x5a2defeb
             ]
             .to_vec()
-        );*/
+        );
     }
 
     #[test]
diff --git a/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf
index 98d15aac574510f6ef7609aaaf412514415e8982..03669901429a1d4c307a1683f5e168fb73653ea4 100755
GIT binary patch
delta 84
zcmV-a0IUDp#sS>M0kEi0MJ>e#jXJ8<xdfA7h^hsLK<l37f$ep7;rNMqT*sF9wc{n-
qEO@rIhuRwRdh72kT61z^FKuCIZZ2|j0N7w401E&B02s6FP;U}Zttf^7

delta 84
zcmV-a0IUDp#sS>M0kEi0MXCjdKrO`wjXJ8<xdfA7i1>+mT*sF9wd<bdf$ep7;dr*T
qhuRwRdh72kTH__%EOT;WFKuCIZZ2|j0N7w401E&B01&h7P;U}W#VCFN

diff --git a/tests/blake2s-quarter-round-2x/src/main.rs b/tests/blake2s-quarter-round-2x/src/main.rs
index 70fb9f6bd..6bfcb9ac6 100644
--- a/tests/blake2s-quarter-round-2x/src/main.rs
+++ b/tests/blake2s-quarter-round-2x/src/main.rs
@@ -13,17 +13,18 @@ pub fn main() {
 
     syscall_blake2s_quarter_round_2x(a.as_mut_ptr(), b.as_ptr());
 
+    /*
     assert_eq!(a, [
         0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x408705aa, 0x8d07c52d, 0xb9d6aa3a,
         0x88609304, 0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed, 0x87b6b678, 0x7af31ada,
         0x5a2defeb, 0x2cdd25e3,
-    ]);
+    ]);*/
+
 
-    /*
     assert_eq!(a, [
         0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc,
         0x8d07c52d, 0xb9d6aa3a, 0x88609304, 0x408705aa,
         0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7,
         0x2cdd25e3, 0x87b6b678, 0x7af31ada, 0x5a2defeb
-    ]);*/
+    ]);
 }

From 3765d4a168112071c35d19eff02c3a8330237e28 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Thu, 19 Sep 2024 14:24:13 +0300
Subject: [PATCH 21/30] chore: Formatting

---
 core/src/syscall/precompiles/blake2s/quarter_round.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/syscall/precompiles/blake2s/quarter_round.rs b/core/src/syscall/precompiles/blake2s/quarter_round.rs
index 563b2c0c5..2ca40d2cc 100644
--- a/core/src/syscall/precompiles/blake2s/quarter_round.rs
+++ b/core/src/syscall/precompiles/blake2s/quarter_round.rs
@@ -308,7 +308,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0);
                 let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
-                //let v3_new = cols.rotate_right[i + 8].populate(
+                    //let v3_new = cols.rotate_right[i + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -320,7 +320,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 // v[2] = v[2].wrapping_add(v[3]);
                 cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
                 let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
-                //let v2_new = cols.add[i + 4 + 8].populate(
+                    //let v2_new = cols.add[i + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -335,7 +335,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2);
                 let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
-                //let v1_new = cols.rotate_right[i + 4 + 8].populate(
+                    //let v1_new = cols.rotate_right[i + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,

From 7f97a4c47ea528364557adc672434fe55cf5f309 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Thu, 19 Sep 2024 16:22:50 +0300
Subject: [PATCH 22/30] feat: Add 2 more quarter rounds

---
 core/src/syscall/precompiles/blake2s/mod.rs   |  44 ++
 .../precompiles/blake2s/quarter_round.rs      | 391 +++++++++++++++++-
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25436 -> 25436 bytes
 tests/blake2s-quarter-round-2x/src/main.rs    |  10 +-
 4 files changed, 424 insertions(+), 21 deletions(-)

diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index a747c83ef..2f29ff88c 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -332,4 +332,48 @@ mod tests {
             vec![0x2cdd25e3, 0x87b6b678, 0x7af31ada, 0x5a2defeb]
         );
     }
+
+    #[test]
+    fn test_blake2s_quarter_round_2x_shuffle_quarter_round_2x_function() {
+        let mut v: Vec<[u32; 4]> = vec![
+            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
+            [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
+            [0x510e527f, 0x9b05688c, 0xe07c2654, 0x5be0cd19],
+        ];
+        let m = [0, 0, 0, 0];
+        let rd = 16;
+        let rb = 12;
+        quarter_round(&mut v, rd, rb, m);
+
+        let rd = 8;
+        let rb = 7;
+        quarter_round(&mut v, rd, rb, m);
+        shuffle(&mut v);
+
+        let rd = 16;
+        let rb = 12;
+        quarter_round(&mut v, rd, rb, m);
+
+        let rd = 8;
+        let rb = 7;
+        quarter_round(&mut v, rd, rb, m);
+
+        assert_eq!(
+            v[0].to_vec(),
+            vec![0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3]
+        );
+        assert_eq!(
+            v[1].to_vec(),
+            vec![0x301095b, 0xb151a3c2, 0x5e17f96f, 0x515f5af4]
+        );
+        assert_eq!(
+            v[2].to_vec(),
+            vec![0x990c6d13, 0x76fff6f1, 0xc561666d, 0xf291605]
+        );
+        assert_eq!(
+            v[3].to_vec(),
+            vec![0x97fd885e, 0x1e53bf19, 0x6fe4a680, 0x8e33663]
+        );
+    }
 }
diff --git a/core/src/syscall/precompiles/blake2s/quarter_round.rs b/core/src/syscall/precompiles/blake2s/quarter_round.rs
index 2ca40d2cc..d7cdab70f 100644
--- a/core/src/syscall/precompiles/blake2s/quarter_round.rs
+++ b/core/src/syscall/precompiles/blake2s/quarter_round.rs
@@ -76,8 +76,10 @@ impl Syscall for Blake2sQuarterRound2xChip {
         let mut a = ctx.slice_unsafe(a_ptr, 16);
         let mut a_clone = a.clone();
 
-        // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
-        let (b_reads, b) = ctx.mr_slice(b_ptr, 16);
+        // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] ||
+        //    m3[0] || m3[1] || m3[2] || m3[3] || m4[0] || m4[1] || m4[2] || mr[3] ||
+        //    0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 24);
 
         // 1x (m1, R1, R2)
         // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m1)
@@ -153,6 +155,71 @@ impl Syscall for Blake2sQuarterRound2xChip {
         a[12..16].swap(1, 2);
         a[12..16].swap(0, 1);
 
+
+        let mut a = a.clone(); // a after 2x quarter_round
+        let mut a_clone = a.clone();
+
+        // 3x (m3, R1, R2)
+        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m3)
+        for ((v0, v1), m) in a[0..4]
+            .iter_mut()
+            .zip(a_clone[4..8].iter())
+            .zip(b[8..12].iter())
+        {
+            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
+        }
+        a_clone = a.clone();
+
+        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
+            *v3 = (*v3 ^ *v0).rotate_right(R_1);
+        }
+        a_clone = a.clone();
+
+        // v[2] = v[2].wrapping_add(v[3]);
+        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
+            *v2 = (*v2).wrapping_add(*v3);
+        }
+        a_clone = a.clone();
+
+        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
+            *v1 = (*v1 ^ *v2).rotate_right(R_2);
+        }
+
+        // 4x (m4, R3, R4)
+        let mut a = a.clone(); // a after 3x quarter_round
+        let mut a_clone = a.clone();
+
+        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
+        for ((v0, v1), m) in a[0..4]
+            .iter_mut()
+            .zip(a_clone[4..8].iter())
+            .zip(b[12..16].iter())
+        {
+            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
+        }
+        a_clone = a.clone();
+
+        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
+            *v3 = (*v3 ^ *v0).rotate_right(R_3);
+        }
+        a_clone = a.clone();
+
+        // v[2] = v[2].wrapping_add(v[3]);
+        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
+            *v2 = (*v2).wrapping_add(*v3);
+        }
+        a_clone = a.clone();
+
+        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
+            *v1 = (*v1 ^ *v2).rotate_right(R_4);
+        }
+
+        // TODO unshuffle
+
         ctx.clk += 1;
         // Write rotate_right to a_ptr.
         let a_reads_writes = ctx.mw_slice(a_ptr, a.as_slice());
@@ -193,11 +260,11 @@ struct Blake2sQuarterRound2xCols<T> {
     pub shuffled_indices: [T; 16],
 
     pub a: [MemoryWriteCols<T>; 16],
-    pub b: [MemoryReadCols<T>; 16],
+    pub b: [MemoryReadCols<T>; 24],
 
-    pub add: [Add4Operation<T>; 8 * 2],
-    pub xor: [XorOperation<T>; 8 * 2],
-    pub rotate_right: [FixedRotateRightOperation<T>; 8 * 2],
+    pub add: [Add4Operation<T>; 32],
+    pub xor: [XorOperation<T>; 32],
+    pub rotate_right: [FixedRotateRightOperation<T>; 32],
 }
 
 impl<T: PrimeField32> BaseAir<T> for Blake2sQuarterRound2xChip {
@@ -238,7 +305,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
             cols.a_ptr = F::from_canonical_u32(event.a_ptr);
             cols.b_ptr = F::from_canonical_u32(event.b_ptr);
 
-            // populate all v, m, 0
+            // populate all v, m
             for i in 0..16usize {
                 cols.a[i].populate(
                     event.channel,
@@ -248,6 +315,11 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
             }
 
+            // populate zeroes
+            for i in 16..24usize {
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+            }
+
             let v1_shuffle_lookup = vec![1, 2, 3, 0];
             let v2_shuffle_lookup = vec![2, 3, 0, 1];
             let v3_shuffle_lookup = vec![3, 0, 1, 2];
@@ -262,8 +334,11 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 let v3 = event.a_reads_writes[i + 12].value;
                 let m1 = event.b_reads[i].value;
                 let m2 = event.b_reads[i + 4].value;
-                let zero1 = event.b_reads[i + 8].value;
-                let zero2 = event.b_reads[i + 12].value;
+                let m3 = event.b_reads[i + 8].value;
+                let m4 = event.b_reads[i + 12].value;
+                let zero1 = event.b_reads[i + 16].value;
+                let zero2 = event.b_reads[i + 20].value;
+
                 assert_eq!(zero1, 0);
                 assert_eq!(zero2, 0);
 
@@ -343,6 +418,90 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                     R_4 as usize,
                 );
                 assert_eq!((v1 ^ v2).rotate_right(R_4), v1_new);
+
+
+                // 3x (m3, R1, R2)
+                let v0 = v0_new;
+                let v1 = v1_new;
+                let v2 = v2_new;
+                let v3 = v3_new;
+
+                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+                let v0_new = cols.add[i + 16].populate(output, shard, event.channel, v0, v1, m3, zero1);
+                assert_eq!(v0 + v1 + m3 + zero1, v0_new);
+
+                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+                let temp = cols.xor[i + 16].populate(output, shard, event.channel, v3, v0);
+                let v3_new =
+                    cols.rotate_right[i + 16].populate(output, shard, event.channel, temp, R_1 as usize);
+                assert_eq!((v3 ^ v0).rotate_right(R_1), v3_new);
+
+                // v[2] = v[2].wrapping_add(v[3]);
+                let v2_new =
+                    cols.add[i + 16 + 4].populate(output, shard, event.channel, v2, v3, zero1, zero2);
+                assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
+
+                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+                let temp = cols.xor[i + 16 + 4].populate(output, shard, event.channel, v1, v2);
+                let v1_new = cols.rotate_right[i + 16 + 4].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_2 as usize,
+                );
+                assert_eq!((v1 ^ v2).rotate_right(R_2), v1_new);
+
+                // 4x (m4, R3, R4)
+                let v0 = v0_new;
+                let v1 = v1_new;
+                let v2 = v2_new;
+                let v3 = v3_new;
+
+                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
+                let v0_new =
+                    cols.add[i + 16 + 8].populate(output, shard, event.channel, v0, v1, m4, zero1);
+                assert_eq!(v0 + v1 + m4 + zero1, v0_new);
+
+                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
+                //cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
+                let temp = cols.xor[i + 16 + 8].populate(output, shard, event.channel, v3, v0);
+                //let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
+                let v3_new = cols.rotate_right[i + 16 + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_3 as usize,
+                );
+                assert_eq!((v3 ^ v0).rotate_right(R_3), v3_new);
+
+                // v[2] = v[2].wrapping_add(v[3]);
+                //cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
+                //let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
+                let v2_new = cols.add[i + 16 + 4 + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    v2,
+                    v3,
+                    zero1,
+                    zero2,
+                );
+                assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
+
+                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
+                //cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
+                let temp = cols.xor[i + 16 + 4 + 8].populate(output, shard, event.channel, v1, v2);
+                //let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
+                let v1_new = cols.rotate_right[i + 16 + 4 + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_4 as usize,
+                );
+                assert_eq!((v1 ^ v2).rotate_right(R_4), v1_new);
             }
 
             rows.push(row);
@@ -413,6 +572,23 @@ where
             );
         }
 
+        // zeroes
+        for i in 16..24usize {
+            // Eval b
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
+        }
+
+        let v1_shuffle_lookup = vec![1, 2, 3, 0];
+        let v2_shuffle_lookup = vec![2, 3, 0, 1];
+        let v3_shuffle_lookup = vec![3, 0, 1, 2];
+
         for i in 0..4usize {
             // 1x
 
@@ -489,10 +665,6 @@ where
 
             // 2x
 
-            let v1_shuffle_lookup = vec![1, 2, 3, 0];
-            let v2_shuffle_lookup = vec![2, 3, 0, 1];
-            let v3_shuffle_lookup = vec![3, 0, 1, 2];
-
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
                 builder,
@@ -567,6 +739,176 @@ where
                 &local.channel,
                 local.is_real,
             );
+
+
+            // 3x
+            /*
+                v0 : local.add[i + 8]
+                v1 : local.local.rotate_right[v1_shuffle_lookup[i] + 12]
+                v2 : local.add[v2_shuffle_lookup[i] + 12]
+                v3 : local.rotate_right[v3_shuffle_lookup[i] + 8]
+            */
+
+            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+            Add4Operation::<AB::F>::eval(
+                builder,
+                local.add[i + 8].value,     // v0 after x2
+                local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
+                *local.b[i + 8].value(),         // m3
+                *local.b[i + 16].value(),         // zero1
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 16],
+            );
+
+            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x
+                local.add[i + 8].value, // v0 after x2
+                local.xor[i + 16],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 16].value,
+                R_1 as usize,
+                local.rotate_right[i + 16],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+
+            // v[2] = v[2].wrapping_add(v[3]);
+            Add4Operation::<AB::F>::eval(
+                builder,
+                local.add[v2_shuffle_lookup[i] + 12].value, // v2 after 2x
+                local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x
+                *local.b[i + 16].value(),  // zero1
+                *local.b[i + 20].value(), // zero2
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 20],
+            );
+
+
+            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
+                local.add[v2_shuffle_lookup[i] + 12].value, // v2 after 2x
+                local.xor[i + 20],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 20].value,
+                R_2 as usize,
+                local.rotate_right[i + 20],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+
+            // 4x
+
+            /*
+               v0 : local.add[i + 16]
+               v1 : local.rotate_right[i + 20]
+               v2 : local.add[i + 20]
+               v3 : local.rotate_right[i + 16]
+           */
+
+            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+            Add4Operation::<AB::F>::eval(
+                builder,
+                local.add[i + 16].value, // v0 after 3x
+                local.rotate_right[i + 20].value, // v1 after 3x
+                *local.b[i + 12].value(), // m4
+                *local.b[i + 16].value(), // zero1
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 24],
+            );
+
+
+            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                local.rotate_right[i + 16].value, // v3 after 3x
+                local.add[i + 16].value,          // v0 after 3x
+                local.xor[i + 24],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 24].value,
+                R_3 as usize,
+                local.rotate_right[i + 24],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // v[2] = v[2].wrapping_add(v[3]);
+            Add4Operation::<AB::F>::eval(
+                builder,
+                local.add[i + 20].value, // v2 after 3x
+                local.rotate_right[i + 16].value, // v3 after 3x
+                *local.b[i + 16].value(),     // zero1
+                *local.b[i + 20].value(),    // zero2
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 28],
+            );
+
+
+            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                local.rotate_right[i + 20].value, // v1 after 3x
+                local.add[i + 20].value, // v2 after 3x
+                local.xor[i + 28],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 28].value,
+                R_4 as usize,
+                local.rotate_right[i + 28],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
         }
 
         self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
@@ -591,7 +933,7 @@ mod tests {
     use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 16], b: [u32; 16]) -> Program {
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 16], b: [u32; 24]) -> Program {
         let mut instructions = vec![];
         // memory write a
         for (index, word) in a.into_iter().enumerate() {
@@ -653,7 +995,12 @@ mod tests {
                 0x5be0cd19, 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
                 0xe07c2654, 0x5be0cd19,
             ],
-            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, // m1
+                0, 0, 0, 0, // m2
+                0, 0, 0, 0, // m3
+                0, 0, 0, 0, // m4
+                0, 0, 0, 0, // zero_0
+                0, 0, 0, 0], // zero_1
         );
 
         let (_, memory) = run_test_with_memory_inspection(program);
@@ -673,7 +1020,7 @@ mod tests {
             ]
         );*/
 
-        assert_eq!(
+        /*assert_eq!(
             result,
             [
                 0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x8d07c52d, 0xb9d6aa3a, 0x88609304,
@@ -681,7 +1028,19 @@ mod tests {
                 0x7af31ada, 0x5a2defeb
             ]
             .to_vec()
+        );*/
+
+        assert_eq!(
+            result,
+            [
+                0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3,
+                0x301095b, 0xb151a3c2, 0x5e17f96f, 0x515f5af4,
+                0x990c6d13, 0x76fff6f1, 0xc561666d, 0xf291605,
+                0x97fd885e, 0x1e53bf19, 0x6fe4a680, 0x8e33663
+            ]
+                .to_vec()
         );
+
     }
 
     #[test]
diff --git a/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf
index 03669901429a1d4c307a1683f5e168fb73653ea4..1b174b537784bf1df7862ae0773686fea4ed61bf 100755
GIT binary patch
delta 122
zcmV-=0EPeD#sS>M0kE?W1@t2>5ek#I5SIZ4lTZ;q6$=vq0Ssq=001K*0SXfZK>(8l
zK?<{^5%fMlT^pc+_1KFfnzf`I(<^(kTL}RJ!lO~KZ}}Hq^jcq06KxEc@%I0AZDwJ`
c1r{j}UWomd8NX8=fTrYcV>aUmv)E9C5;wgr(*OVf

delta 122
zcmV-=0EPeD#sS>M0kE?W1@<E@5eSpG5SIZ2lTZ;q6$ujo0Sae;001K*0SFTXK>(8l
zK?t*?5%fMlo|O;W5*LSz)KI3z{JC$^EyV|oI;z&W1e0Khss)EY>z?L;?R9tI_=$R4
c$CmiD<0aiJc(%5O+8XnE>+daEv)E9C66&ipR{#J2

diff --git a/tests/blake2s-quarter-round-2x/src/main.rs b/tests/blake2s-quarter-round-2x/src/main.rs
index 6bfcb9ac6..e41fe63cf 100644
--- a/tests/blake2s-quarter-round-2x/src/main.rs
+++ b/tests/blake2s-quarter-round-2x/src/main.rs
@@ -9,7 +9,7 @@ pub fn main() {
         0x5be0cd19, 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
         0xe07c2654, 0x5be0cd19
     ];
-    let b: [u32; 16] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    let b: [u32; 24] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
 
     syscall_blake2s_quarter_round_2x(a.as_mut_ptr(), b.as_ptr());
 
@@ -22,9 +22,9 @@ pub fn main() {
 
 
     assert_eq!(a, [
-        0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc,
-        0x8d07c52d, 0xb9d6aa3a, 0x88609304, 0x408705aa,
-        0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7,
-        0x2cdd25e3, 0x87b6b678, 0x7af31ada, 0x5a2defeb
+        0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3,
+        0x301095b, 0xb151a3c2, 0x5e17f96f, 0x515f5af4,
+        0x990c6d13, 0x76fff6f1, 0xc561666d, 0xf291605,
+        0x97fd885e, 0x1e53bf19, 0x6fe4a680, 0x8e33663
     ]);
 }

From 52637834cc5ce47c3cfcf5c2f571f0d34f45d5d0 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Thu, 19 Sep 2024 17:23:07 +0300
Subject: [PATCH 23/30] feat: Add unshuffle operation

---
 core/src/syscall/precompiles/blake2s/mod.rs   |  11 +-
 .../blake2s/{quarter_round.rs => round.rs}    | 193 +++++++++---------
 core/src/utils/programs.rs                    |   4 +-
 .../Cargo.lock                                |   0
 .../Cargo.toml                                |   0
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25436 -> 25436 bytes
 .../src/main.rs                               |  16 +-
 ...s_quarter_round_2x.rs => blake2s_round.rs} |   0
 zkvm/entrypoint/src/syscalls/mod.rs           |   2 +-
 9 files changed, 104 insertions(+), 122 deletions(-)
 rename core/src/syscall/precompiles/blake2s/{quarter_round.rs => round.rs} (87%)
 rename tests/{blake2s-quarter-round-2x => blake2s-round}/Cargo.lock (100%)
 rename tests/{blake2s-quarter-round-2x => blake2s-round}/Cargo.toml (100%)
 rename tests/{blake2s-quarter-round-2x => blake2s-round}/elf/riscv32im-succinct-zkvm-elf (99%)
 rename tests/{blake2s-quarter-round-2x => blake2s-round}/src/main.rs (52%)
 rename zkvm/entrypoint/src/syscalls/{blake2s_quarter_round_2x.rs => blake2s_round.rs} (100%)

diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 2f29ff88c..83844f82c 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -1,6 +1,6 @@
 mod add_2;
 mod add_3;
-mod quarter_round;
+mod round;
 mod xor_rotate_16; // based on sha-extend
 mod xor_rotate_right_12;
 mod xor_rotate_right_16;
@@ -9,7 +9,7 @@ mod xor_rotate_right_8;
 
 pub use add_2::*;
 pub use add_3::*;
-pub use quarter_round::*;
+pub use round::*;
 pub use xor_rotate_16::*; // based on sha-extend
 pub use xor_rotate_right_12::*;
 pub use xor_rotate_right_16::*;
@@ -358,6 +358,7 @@ mod tests {
         let rd = 8;
         let rb = 7;
         quarter_round(&mut v, rd, rb, m);
+        unshuffle(&mut v);
 
         assert_eq!(
             v[0].to_vec(),
@@ -365,15 +366,15 @@ mod tests {
         );
         assert_eq!(
             v[1].to_vec(),
-            vec![0x301095b, 0xb151a3c2, 0x5e17f96f, 0x515f5af4]
+            vec![0x515f5af4, 0x301095b, 0xb151a3c2, 0x5e17f96f]
         );
         assert_eq!(
             v[2].to_vec(),
-            vec![0x990c6d13, 0x76fff6f1, 0xc561666d, 0xf291605]
+            vec![0xc561666d, 0xf291605, 0x990c6d13, 0x76fff6f1]
         );
         assert_eq!(
             v[3].to_vec(),
-            vec![0x97fd885e, 0x1e53bf19, 0x6fe4a680, 0x8e33663]
+            vec![0x1e53bf19, 0x6fe4a680, 0x8e33663, 0x97fd885e]
         );
     }
 }
diff --git a/core/src/syscall/precompiles/blake2s/quarter_round.rs b/core/src/syscall/precompiles/blake2s/round.rs
similarity index 87%
rename from core/src/syscall/precompiles/blake2s/quarter_round.rs
rename to core/src/syscall/precompiles/blake2s/round.rs
index d7cdab70f..834f597c4 100644
--- a/core/src/syscall/precompiles/blake2s/quarter_round.rs
+++ b/core/src/syscall/precompiles/blake2s/round.rs
@@ -30,21 +30,21 @@ impl Blake2sQuarterRound2xChip {
     pub fn new() -> Self {
         Blake2sQuarterRound2xChip
     }
-    pub fn constrain_shuffled_indices<AB: SphinxAirBuilder>(
+    pub fn constrain_shuffled_unshuffled_indices<AB: SphinxAirBuilder>(
         &self,
         builder: &mut AB,
-        shuffled_indices: &[AB::Var],
+        indices: &[AB::Var],
         is_real: AB::Var,
     ) {
         for index in 0..4 {
             builder
                 .when(is_real)
-                .assert_eq(shuffled_indices[index], AB::F::from_canonical_usize(0));
+                .assert_eq(indices[index], AB::F::from_canonical_usize(0));
         }
-        for index in 4..shuffled_indices.len() {
+        for index in 4..indices.len() {
             builder
                 .when(is_real)
-                .assert_eq(shuffled_indices[index], AB::F::from_canonical_usize(1));
+                .assert_eq(indices[index], AB::F::from_canonical_usize(1));
         }
     }
 }
@@ -155,7 +155,6 @@ impl Syscall for Blake2sQuarterRound2xChip {
         a[12..16].swap(1, 2);
         a[12..16].swap(0, 1);
 
-
         let mut a = a.clone(); // a after 2x quarter_round
         let mut a_clone = a.clone();
 
@@ -218,7 +217,20 @@ impl Syscall for Blake2sQuarterRound2xChip {
             *v1 = (*v1 ^ *v2).rotate_right(R_4);
         }
 
-        // TODO unshuffle
+        // unshuffle
+        // v[1]
+        a[4..8].swap(2, 3);
+        a[4..8].swap(1, 2);
+        a[4..8].swap(0, 1);
+
+        // v[2]
+        a[8..12].swap(0, 2);
+        a[8..12].swap(1, 3);
+
+        // v[3]
+        a[12..16].swap(0, 3);
+        a[12..16].swap(0, 1);
+        a[12..16].swap(1, 2);
 
         ctx.clk += 1;
         // Write rotate_right to a_ptr.
@@ -258,6 +270,7 @@ struct Blake2sQuarterRound2xCols<T> {
     pub b_ptr: T,
 
     pub shuffled_indices: [T; 16],
+    pub unshuffled_indices: [T; 16],
 
     pub a: [MemoryWriteCols<T>; 16],
     pub b: [MemoryReadCols<T>; 24],
@@ -324,8 +337,10 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
             let v2_shuffle_lookup = vec![2, 3, 0, 1];
             let v3_shuffle_lookup = vec![3, 0, 1, 2];
 
-            // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
-            // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
+            let v1_unshuffle_lookup = v1_shuffle_lookup.clone();
+            let v2_unshuffle_lookup = v2_shuffle_lookup.clone();
+            let v3_unshuffle_lookup = v3_shuffle_lookup.clone();
+
             for i in 0..4usize {
                 // 1x (m1, R1, R2)
                 let v0 = event.a_reads_writes[i].value;
@@ -419,7 +434,6 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 );
                 assert_eq!((v1 ^ v2).rotate_right(R_4), v1_new);
 
-
                 // 3x (m3, R1, R2)
                 let v0 = v0_new;
                 let v1 = v1_new;
@@ -427,18 +441,31 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 let v3 = v3_new;
 
                 // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-                let v0_new = cols.add[i + 16].populate(output, shard, event.channel, v0, v1, m3, zero1);
+                let v0_new =
+                    cols.add[i + 16].populate(output, shard, event.channel, v0, v1, m3, zero1);
                 assert_eq!(v0 + v1 + m3 + zero1, v0_new);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
                 let temp = cols.xor[i + 16].populate(output, shard, event.channel, v3, v0);
-                let v3_new =
-                    cols.rotate_right[i + 16].populate(output, shard, event.channel, temp, R_1 as usize);
+                let v3_new = cols.rotate_right[i + 16].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_1 as usize,
+                );
                 assert_eq!((v3 ^ v0).rotate_right(R_1), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                let v2_new =
-                    cols.add[i + 16 + 4].populate(output, shard, event.channel, v2, v3, zero1, zero2);
+                let v2_new = cols.add[i + 16 + 4].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    v2,
+                    v3,
+                    zero1,
+                    zero2,
+                );
                 assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
@@ -464,10 +491,10 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 assert_eq!(v0 + v1 + m4 + zero1, v0_new);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
-                //cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
+                cols.unshuffled_indices[i + 12] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 16 + 8].populate(output, shard, event.channel, v3, v0);
-                //let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
-                let v3_new = cols.rotate_right[i + 16 + 8].populate(
+                let v3_new = cols.rotate_right[v3_unshuffle_lookup[i] + 16 + 8].populate(
+                    //let v3_new = cols.rotate_right[i + 16 + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -477,9 +504,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 assert_eq!((v3 ^ v0).rotate_right(R_3), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                //cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
-                //let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
-                let v2_new = cols.add[i + 16 + 4 + 8].populate(
+                cols.unshuffled_indices[i + 8] = F::from_canonical_u32(1);
+                let v2_new = cols.add[v2_unshuffle_lookup[i] + 16 + 4 + 8].populate(
+                    //let v2_new = cols.add[i + 16 + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -491,10 +518,10 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
-                //cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
+                cols.unshuffled_indices[i + 4] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 16 + 4 + 8].populate(output, shard, event.channel, v1, v2);
-                //let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
-                let v1_new = cols.rotate_right[i + 16 + 4 + 8].populate(
+                let v1_new = cols.rotate_right[v1_unshuffle_lookup[i] + 16 + 4 + 8].populate(
+                    //let v1_new = cols.rotate_right[i + 16 + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
@@ -589,6 +616,10 @@ where
         let v2_shuffle_lookup = vec![2, 3, 0, 1];
         let v3_shuffle_lookup = vec![3, 0, 1, 2];
 
+        let v1_unshuffle_lookup = v1_shuffle_lookup.clone();
+        let v2_unshuffle_lookup = v2_shuffle_lookup.clone();
+        let v3_unshuffle_lookup = v3_shuffle_lookup.clone();
+
         for i in 0..4usize {
             // 1x
 
@@ -696,7 +727,6 @@ where
                 local.xor[i + 8].value,
                 R_3 as usize,
                 local.rotate_right[v3_shuffle_lookup[i] + 8],
-                //local.rotate_right[i + 8],
                 local.shard,
                 &local.channel,
                 local.is_real,
@@ -713,7 +743,6 @@ where
                 local.channel,
                 local.is_real,
                 local.add[v2_shuffle_lookup[i] + 12],
-                //local.add[i + 12],
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
@@ -734,28 +763,23 @@ where
                 local.xor[i + 12].value,
                 R_4 as usize,
                 local.rotate_right[v1_shuffle_lookup[i] + 12],
-                //local.rotate_right[i + 12],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
+        }
 
+        self.constrain_shuffled_unshuffled_indices(builder, &local.shuffled_indices, local.is_real);
 
+        for i in 0..4usize {
             // 3x
-            /*
-                v0 : local.add[i + 8]
-                v1 : local.local.rotate_right[v1_shuffle_lookup[i] + 12]
-                v2 : local.add[v2_shuffle_lookup[i] + 12]
-                v3 : local.rotate_right[v3_shuffle_lookup[i] + 8]
-            */
-
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
                 builder,
-                local.add[i + 8].value,     // v0 after x2
+                local.add[i + 8].value, // v0 after x2
                 local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
-                *local.b[i + 8].value(),         // m3
-                *local.b[i + 16].value(),         // zero1
+                *local.b[i + 8].value(), // m3
+                *local.b[i + 16].value(), // zero1
                 local.shard,
                 local.channel,
                 local.is_real,
@@ -767,7 +791,7 @@ where
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x
-                local.add[i + 8].value, // v0 after x2
+                local.add[i + 8].value,                             // v0 after x2
                 local.xor[i + 16],
                 local.shard,
                 &local.channel,
@@ -785,34 +809,31 @@ where
                 local.is_real,
             );
 
-
             // v[2] = v[2].wrapping_add(v[3]);
             Add4Operation::<AB::F>::eval(
                 builder,
                 local.add[v2_shuffle_lookup[i] + 12].value, // v2 after 2x
                 local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x
-                *local.b[i + 16].value(),  // zero1
-                *local.b[i + 20].value(), // zero2
+                *local.b[i + 16].value(),                   // zero1
+                *local.b[i + 20].value(),                   // zero2
                 local.shard,
                 local.channel,
                 local.is_real,
                 local.add[i + 20],
             );
 
-
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
             // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
-                local.add[v2_shuffle_lookup[i] + 12].value, // v2 after 2x
+                local.add[v2_shuffle_lookup[i] + 12].value,          // v2 after 2x
                 local.xor[i + 20],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
 
-
             // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
@@ -824,30 +845,20 @@ where
                 local.is_real,
             );
 
-
             // 4x
-
-            /*
-               v0 : local.add[i + 16]
-               v1 : local.rotate_right[i + 20]
-               v2 : local.add[i + 20]
-               v3 : local.rotate_right[i + 16]
-           */
-
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
                 builder,
-                local.add[i + 16].value, // v0 after 3x
+                local.add[i + 16].value,          // v0 after 3x
                 local.rotate_right[i + 20].value, // v1 after 3x
-                *local.b[i + 12].value(), // m4
-                *local.b[i + 16].value(), // zero1
+                *local.b[i + 12].value(),         // m4
+                *local.b[i + 16].value(),         // zero1
                 local.shard,
                 local.channel,
                 local.is_real,
                 local.add[i + 24],
             );
 
-
             // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
             // Eval XOR
             XorOperation::<AB::F>::eval(
@@ -860,13 +871,12 @@ where
                 local.is_real,
             );
 
-
             // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
                 local.xor[i + 24].value,
                 R_3 as usize,
-                local.rotate_right[i + 24],
+                local.rotate_right[v3_unshuffle_lookup[i] + 24],
                 local.shard,
                 &local.channel,
                 local.is_real,
@@ -875,23 +885,22 @@ where
             // v[2] = v[2].wrapping_add(v[3]);
             Add4Operation::<AB::F>::eval(
                 builder,
-                local.add[i + 20].value, // v2 after 3x
+                local.add[i + 20].value,          // v2 after 3x
                 local.rotate_right[i + 16].value, // v3 after 3x
-                *local.b[i + 16].value(),     // zero1
-                *local.b[i + 20].value(),    // zero2
+                *local.b[i + 16].value(),         // zero1
+                *local.b[i + 20].value(),         // zero2
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[i + 28],
+                local.add[v2_unshuffle_lookup[i] + 28],
             );
 
-
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
             // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i + 20].value, // v1 after 3x
-                local.add[i + 20].value, // v2 after 3x
+                local.add[i + 20].value,          // v2 after 3x
                 local.xor[i + 28],
                 local.shard,
                 &local.channel,
@@ -903,15 +912,18 @@ where
                 builder,
                 local.xor[i + 28].value,
                 R_4 as usize,
-                local.rotate_right[i + 28],
+                local.rotate_right[v1_unshuffle_lookup[i] + 28],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
-
         }
 
-        self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
+        self.constrain_shuffled_unshuffled_indices(
+            builder,
+            &local.unshuffled_indices,
+            local.is_real,
+        );
 
         builder.receive_syscall(
             local.shard,
@@ -929,7 +941,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::BLAKE2S_QUARTER_ROUND_2X_ELF;
+    use crate::utils::tests::BLAKE2S_ROUND_ELF;
     use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
     use crate::Program;
 
@@ -979,12 +991,9 @@ mod tests {
     }
 
     #[test]
-    fn test_blake2s_quarter_round_2x_precompile() {
+    fn test_blake2s_round_precompile() {
         setup_logger();
 
-        // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
-        // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 ||
-
         let a_ptr = 100100100;
         let b_ptr = 200200200;
         let program = risc_v_program(
@@ -995,12 +1004,14 @@ mod tests {
                 0x5be0cd19, 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
                 0xe07c2654, 0x5be0cd19,
             ],
-            [0, 0, 0, 0, // m1
+            [
+                0, 0, 0, 0, // m1
                 0, 0, 0, 0, // m2
                 0, 0, 0, 0, // m3
                 0, 0, 0, 0, // m4
                 0, 0, 0, 0, // zero_0
-                0, 0, 0, 0], // zero_1
+                0, 0, 0, 0,
+            ], // zero_1
         );
 
         let (_, memory) = run_test_with_memory_inspection(program);
@@ -1010,43 +1021,21 @@ mod tests {
             result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
         }
 
-        /*
         assert_eq!(
             result,
             [
-                0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x408705aa, 0x8d07c52d, 0xb9d6aa3a,
-                0x88609304, 0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed, 0x87b6b678, 0x7af31ada,
-                0x5a2defeb, 0x2cdd25e3,
-            ]
-        );*/
-
-        /*assert_eq!(
-            result,
-            [
-                0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x8d07c52d, 0xb9d6aa3a, 0x88609304,
-                0x408705aa, 0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7, 0x2cdd25e3, 0x87b6b678,
-                0x7af31ada, 0x5a2defeb
+                0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3, 0x515f5af4, 0x301095b, 0xb151a3c2,
+                0x5e17f96f, 0xc561666d, 0xf291605, 0x990c6d13, 0x76fff6f1, 0x1e53bf19, 0x6fe4a680,
+                0x8e33663, 0x97fd885e,
             ]
             .to_vec()
-        );*/
-
-        assert_eq!(
-            result,
-            [
-                0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3,
-                0x301095b, 0xb151a3c2, 0x5e17f96f, 0x515f5af4,
-                0x990c6d13, 0x76fff6f1, 0xc561666d, 0xf291605,
-                0x97fd885e, 0x1e53bf19, 0x6fe4a680, 0x8e33663
-            ]
-                .to_vec()
         );
-
     }
 
     #[test]
-    fn test_blake2s_quarter_round_2x_program() {
+    fn test_blake2s_round_program() {
         setup_logger();
-        let program = Program::from(BLAKE2S_QUARTER_ROUND_2X_ELF);
+        let program = Program::from(BLAKE2S_ROUND_ELF);
         run_test(program).unwrap();
     }
 }
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index ae2a8665d..5b90fc220 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -144,8 +144,8 @@ pub mod tests {
     pub const BLAKE2S_XOR_ROTATE_RIGHT_7_ELF: &[u8] =
         include_bytes!("../../../tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf");
 
-    pub const BLAKE2S_QUARTER_ROUND_2X_ELF: &[u8] =
-        include_bytes!("../../../tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf");
+    pub const BLAKE2S_ROUND_ELF: &[u8] =
+        include_bytes!("../../../tests/blake2s-round/elf/riscv32im-succinct-zkvm-elf");
 
     pub const PANIC_ELF: &[u8] =
         include_bytes!("../../../tests/panic/elf/riscv32im-succinct-zkvm-elf");
diff --git a/tests/blake2s-quarter-round-2x/Cargo.lock b/tests/blake2s-round/Cargo.lock
similarity index 100%
rename from tests/blake2s-quarter-round-2x/Cargo.lock
rename to tests/blake2s-round/Cargo.lock
diff --git a/tests/blake2s-quarter-round-2x/Cargo.toml b/tests/blake2s-round/Cargo.toml
similarity index 100%
rename from tests/blake2s-quarter-round-2x/Cargo.toml
rename to tests/blake2s-round/Cargo.toml
diff --git a/tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-round/elf/riscv32im-succinct-zkvm-elf
similarity index 99%
rename from tests/blake2s-quarter-round-2x/elf/riscv32im-succinct-zkvm-elf
rename to tests/blake2s-round/elf/riscv32im-succinct-zkvm-elf
index 1b174b537784bf1df7862ae0773686fea4ed61bf..dad5a964e749b5533e34c044b8afc7f8ad93101e 100755
GIT binary patch
delta 84
zcmV-a0IUDp#sS>M0kEi0Mf6%<QCkTC1Hz+Gv2XboUTtP!#RV2A4-;(+neq1jb{W4@
q9)PCgZ(}y&2wsT&mveGsFKuCIZZ2|j0N7w401E&B01&h7P;U|<fFgbX

delta 84
zcmV-a0IUDp#sS>M0kEi0MOz601Hz+Gv2XboUi4aDQ4?(pneq1jc5P;1#RV2A4_=7<
qml?lP9)PCgZ(}y&2y=2{FKuCIZZ2|j0N7w401E&B02s6FP;U}9z#@hK

diff --git a/tests/blake2s-quarter-round-2x/src/main.rs b/tests/blake2s-round/src/main.rs
similarity index 52%
rename from tests/blake2s-quarter-round-2x/src/main.rs
rename to tests/blake2s-round/src/main.rs
index e41fe63cf..7ab5a38e0 100644
--- a/tests/blake2s-quarter-round-2x/src/main.rs
+++ b/tests/blake2s-round/src/main.rs
@@ -1,7 +1,7 @@
 #![no_main]
 sphinx_zkvm::entrypoint!(main);
 
-use sphinx_zkvm::syscalls::blake2s_quarter_round_2x::syscall_blake2s_quarter_round_2x;
+use sphinx_zkvm::syscalls::blake2s_round::syscall_blake2s_quarter_round_2x;
 
 pub fn main() {
     let mut a: [u32; 16] = [
@@ -13,18 +13,10 @@ pub fn main() {
 
     syscall_blake2s_quarter_round_2x(a.as_mut_ptr(), b.as_ptr());
 
-    /*
-    assert_eq!(a, [
-        0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc, 0x408705aa, 0x8d07c52d, 0xb9d6aa3a,
-        0x88609304, 0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed, 0x87b6b678, 0x7af31ada,
-        0x5a2defeb, 0x2cdd25e3,
-    ]);*/
-
-
     assert_eq!(a, [
         0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3,
-        0x301095b, 0xb151a3c2, 0x5e17f96f, 0x515f5af4,
-        0x990c6d13, 0x76fff6f1, 0xc561666d, 0xf291605,
-        0x97fd885e, 0x1e53bf19, 0x6fe4a680, 0x8e33663
+        0x515f5af4, 0x301095b, 0xb151a3c2, 0x5e17f96f,
+        0xc561666d, 0xf291605, 0x990c6d13, 0x76fff6f1,
+        0x1e53bf19, 0x6fe4a680, 0x8e33663, 0x97fd885e,
     ]);
 }
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_quarter_round_2x.rs b/zkvm/entrypoint/src/syscalls/blake2s_round.rs
similarity index 100%
rename from zkvm/entrypoint/src/syscalls/blake2s_quarter_round_2x.rs
rename to zkvm/entrypoint/src/syscalls/blake2s_round.rs
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 2d1c8b0a7..647e5202a 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -15,7 +15,7 @@ mod verify;
 
 pub mod blake2s_add_2;
 pub mod blake2s_add_3;
-pub mod blake2s_quarter_round_2x;
+pub mod blake2s_round;
 pub mod blake2s_xor_rotate_16;
 pub mod blake2s_xor_rotate_right_12;
 pub mod blake2s_xor_rotate_right_16;

From 48f226661e613808248aac5f6acf554b99a85390 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Fri, 20 Sep 2024 21:01:09 +0300
Subject: [PATCH 24/30] feat: Blake2s round syscall testing with randomized
 input

---
 core/src/runtime/record.rs                    | 171 +-----
 core/src/runtime/syscall.rs                   | 115 +---
 core/src/stark/air.rs                         |  52 +-
 core/src/syscall/precompiles/blake2s/add_2.rs | 368 ------------
 core/src/syscall/precompiles/blake2s/add_3.rs | 371 ------------
 core/src/syscall/precompiles/blake2s/mod.rs   | 315 ++++------
 core/src/syscall/precompiles/blake2s/round.rs | 402 +++++++------
 .../precompiles/blake2s/xor_rotate_16/air.rs  | 291 ----------
 .../blake2s/xor_rotate_16/columns.rs          |  71 ---
 .../blake2s/xor_rotate_16/execute.rs          | 101 ----
 .../blake2s/xor_rotate_16/flags.rs            | 130 -----
 .../precompiles/blake2s/xor_rotate_16/mod.rs  | 116 ----
 .../blake2s/xor_rotate_16/trace.rs            | 178 ------
 .../blake2s/xor_rotate_right_12.rs            | 357 ------------
 .../blake2s/xor_rotate_right_16.rs            | 357 ------------
 .../precompiles/blake2s/xor_rotate_right_7.rs | 357 ------------
 .../precompiles/blake2s/xor_rotate_right_8.rs | 357 ------------
 core/src/utils/programs.rs                    |  23 -
 tests/blake2s-add2/Cargo.lock                 | 539 ------------------
 tests/blake2s-add2/Cargo.toml                 |   8 -
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25140 -> 0 bytes
 tests/blake2s-add2/src/main.rs                |  13 -
 tests/blake2s-add3/Cargo.lock                 | 539 ------------------
 tests/blake2s-add3/Cargo.toml                 |   8 -
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25156 -> 0 bytes
 tests/blake2s-add3/src/main.rs                |  13 -
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25436 -> 22700 bytes
 tests/blake2s-round/src/main.rs               |  11 +-
 tests/blake2s-xor-rotate-16/Cargo.lock        | 539 ------------------
 tests/blake2s-xor-rotate-16/Cargo.toml        |   8 -
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 22924 -> 0 bytes
 tests/blake2s-xor-rotate-16/src/main.rs       |  13 -
 tests/blake2s-xor-rotate-right-12/Cargo.lock  | 539 ------------------
 tests/blake2s-xor-rotate-right-12/Cargo.toml  |   8 -
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25140 -> 0 bytes
 tests/blake2s-xor-rotate-right-12/src/main.rs |  13 -
 tests/blake2s-xor-rotate-right-16/Cargo.lock  | 539 ------------------
 tests/blake2s-xor-rotate-right-16/Cargo.toml  |   8 -
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25140 -> 0 bytes
 tests/blake2s-xor-rotate-right-16/src/main.rs |  29 -
 tests/blake2s-xor-rotate-right-7/Cargo.lock   | 539 ------------------
 tests/blake2s-xor-rotate-right-7/Cargo.toml   |   8 -
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25140 -> 0 bytes
 tests/blake2s-xor-rotate-right-7/src/main.rs  |  13 -
 tests/blake2s-xor-rotate-right-8/Cargo.lock   | 539 ------------------
 tests/blake2s-xor-rotate-right-8/Cargo.toml   |   8 -
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 25140 -> 0 bytes
 tests/blake2s-xor-rotate-right-8/src/main.rs  |  13 -
 zkvm/entrypoint/src/syscalls/blake2s_add_2.rs |  19 -
 zkvm/entrypoint/src/syscalls/blake2s_add_3.rs |  19 -
 zkvm/entrypoint/src/syscalls/blake2s_round.rs |   4 +-
 .../src/syscalls/blake2s_xor_rotate_16.rs     |  19 -
 .../syscalls/blake2s_xor_rotate_right_12.rs   |  19 -
 .../syscalls/blake2s_xor_rotate_right_16.rs   |  19 -
 .../syscalls/blake2s_xor_rotate_right_7.rs    |  19 -
 .../syscalls/blake2s_xor_rotate_right_8.rs    |  19 -
 zkvm/entrypoint/src/syscalls/mod.rs           |  24 +-
 57 files changed, 368 insertions(+), 7872 deletions(-)
 delete mode 100644 core/src/syscall/precompiles/blake2s/add_2.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/add_3.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/air.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/columns.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/execute.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/flags.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/mod.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_16/trace.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_right_12.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_right_16.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_right_7.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/xor_rotate_right_8.rs
 delete mode 100644 tests/blake2s-add2/Cargo.lock
 delete mode 100644 tests/blake2s-add2/Cargo.toml
 delete mode 100755 tests/blake2s-add2/elf/riscv32im-succinct-zkvm-elf
 delete mode 100644 tests/blake2s-add2/src/main.rs
 delete mode 100644 tests/blake2s-add3/Cargo.lock
 delete mode 100644 tests/blake2s-add3/Cargo.toml
 delete mode 100755 tests/blake2s-add3/elf/riscv32im-succinct-zkvm-elf
 delete mode 100644 tests/blake2s-add3/src/main.rs
 delete mode 100644 tests/blake2s-xor-rotate-16/Cargo.lock
 delete mode 100644 tests/blake2s-xor-rotate-16/Cargo.toml
 delete mode 100755 tests/blake2s-xor-rotate-16/elf/riscv32im-succinct-zkvm-elf
 delete mode 100644 tests/blake2s-xor-rotate-16/src/main.rs
 delete mode 100644 tests/blake2s-xor-rotate-right-12/Cargo.lock
 delete mode 100644 tests/blake2s-xor-rotate-right-12/Cargo.toml
 delete mode 100755 tests/blake2s-xor-rotate-right-12/elf/riscv32im-succinct-zkvm-elf
 delete mode 100644 tests/blake2s-xor-rotate-right-12/src/main.rs
 delete mode 100644 tests/blake2s-xor-rotate-right-16/Cargo.lock
 delete mode 100644 tests/blake2s-xor-rotate-right-16/Cargo.toml
 delete mode 100755 tests/blake2s-xor-rotate-right-16/elf/riscv32im-succinct-zkvm-elf
 delete mode 100644 tests/blake2s-xor-rotate-right-16/src/main.rs
 delete mode 100644 tests/blake2s-xor-rotate-right-7/Cargo.lock
 delete mode 100644 tests/blake2s-xor-rotate-right-7/Cargo.toml
 delete mode 100755 tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf
 delete mode 100644 tests/blake2s-xor-rotate-right-7/src/main.rs
 delete mode 100644 tests/blake2s-xor-rotate-right-8/Cargo.lock
 delete mode 100644 tests/blake2s-xor-rotate-right-8/Cargo.toml
 delete mode 100755 tests/blake2s-xor-rotate-right-8/elf/riscv32im-succinct-zkvm-elf
 delete mode 100644 tests/blake2s-xor-rotate-right-8/src/main.rs
 delete mode 100644 zkvm/entrypoint/src/syscalls/blake2s_add_2.rs
 delete mode 100644 zkvm/entrypoint/src/syscalls/blake2s_add_3.rs
 delete mode 100644 zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_16.rs
 delete mode 100644 zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_12.rs
 delete mode 100644 zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_16.rs
 delete mode 100644 zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_7.rs
 delete mode 100644 zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_8.rs

diff --git a/core/src/runtime/record.rs b/core/src/runtime/record.rs
index 85748a803..dbbbee849 100644
--- a/core/src/runtime/record.rs
+++ b/core/src/runtime/record.rs
@@ -10,13 +10,7 @@ use super::{program::Program, Opcode};
 use crate::runtime::MemoryInitializeFinalizeEvent;
 use crate::runtime::MemoryRecordEnum;
 use crate::stark::MachineRecord;
-use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sAdd2Event, Blake2sAdd3Chip, Blake2sAdd3Event,
-    Blake2sQuarterRound2xChip, Blake2sQuarterRound2xEvent, Blake2sXorRotate16Chip,
-    Blake2sXorRotate16Event, Blake2sXorRotateRight12Chip, Blake2sXorRotateRight12Event,
-    Blake2sXorRotateRight16Chip, Blake2sXorRotateRight16Event, Blake2sXorRotateRight7Chip,
-    Blake2sXorRotateRight7Event, Blake2sXorRotateRight8Chip, Blake2sXorRotateRight8Event,
-};
+use crate::syscall::precompiles::blake2s::{Blake2sRoundChip, Blake2sRoundEvent};
 use crate::syscall::precompiles::edwards::EdDecompressEvent;
 use crate::syscall::precompiles::keccak256::KeccakPermuteEvent;
 use crate::syscall::precompiles::sha256::{ShaCompressEvent, ShaExtendEvent};
@@ -133,14 +127,7 @@ pub struct ExecutionRecord {
     pub bls12381_g2_double_events: Vec<Bls12381G2AffineDoubleEvent>,
 
     // Blake2s
-    pub blake2s_xor_rotate_right_16_events: Vec<Blake2sXorRotateRight16Event>,
-    pub blake2s_xor_rotate_16_events: Vec<Blake2sXorRotate16Event>, // based on sha-extend
-    pub blake2s_add_2_events: Vec<Blake2sAdd2Event>,
-    pub blake2s_add_3_events: Vec<Blake2sAdd3Event>,
-    pub blake2s_xor_rotate_right_12_events: Vec<Blake2sXorRotateRight12Event>,
-    pub blake2s_xor_rotate_right_8_events: Vec<Blake2sXorRotateRight8Event>,
-    pub blake2s_xor_rotate_right_7_events: Vec<Blake2sXorRotateRight7Event>,
-    pub blake2s_quarter_round_2x_events: Vec<Blake2sQuarterRound2xEvent>,
+    pub blake2s_round_events: Vec<Blake2sRoundEvent>,
 
     pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
 
@@ -335,51 +322,9 @@ impl EventLens<EdDecompressChip<Ed25519Parameters>> for ExecutionRecord {
     }
 }
 
-impl EventLens<Blake2sXorRotateRight16Chip> for ExecutionRecord {
-    fn events(&self) -> <Blake2sXorRotateRight16Chip as crate::air::WithEvents<'_>>::Events {
-        &self.blake2s_xor_rotate_right_16_events
-    }
-}
-
-impl EventLens<Blake2sXorRotate16Chip> for ExecutionRecord {
-    fn events(&self) -> <Blake2sXorRotate16Chip as crate::air::WithEvents<'_>>::Events {
-        &self.blake2s_xor_rotate_16_events
-    }
-}
-
-impl EventLens<Blake2sAdd2Chip> for ExecutionRecord {
-    fn events(&self) -> <Blake2sAdd2Chip as crate::air::WithEvents<'_>>::Events {
-        &self.blake2s_add_2_events
-    }
-}
-
-impl EventLens<Blake2sAdd3Chip> for ExecutionRecord {
-    fn events(&self) -> <Blake2sAdd3Chip as crate::air::WithEvents<'_>>::Events {
-        &self.blake2s_add_3_events
-    }
-}
-
-impl EventLens<Blake2sXorRotateRight12Chip> for ExecutionRecord {
-    fn events(&self) -> <Blake2sXorRotateRight12Chip as crate::air::WithEvents<'_>>::Events {
-        &self.blake2s_xor_rotate_right_12_events
-    }
-}
-
-impl EventLens<Blake2sXorRotateRight8Chip> for ExecutionRecord {
-    fn events(&self) -> <Blake2sXorRotateRight8Chip as crate::air::WithEvents<'_>>::Events {
-        &self.blake2s_xor_rotate_right_8_events
-    }
-}
-
-impl EventLens<Blake2sXorRotateRight7Chip> for ExecutionRecord {
-    fn events(&self) -> <Blake2sXorRotateRight7Chip as crate::air::WithEvents<'_>>::Events {
-        &self.blake2s_xor_rotate_right_7_events
-    }
-}
-
-impl EventLens<Blake2sQuarterRound2xChip> for ExecutionRecord {
-    fn events(&self) -> <Blake2sQuarterRound2xChip as crate::air::WithEvents<'_>>::Events {
-        &self.blake2s_quarter_round_2x_events
+impl EventLens<Blake2sRoundChip> for ExecutionRecord {
+    fn events(&self) -> <Blake2sRoundChip as crate::air::WithEvents<'_>>::Events {
+        &self.blake2s_round_events
     }
 }
 
@@ -530,43 +475,10 @@ impl MachineRecord for ExecutionRecord {
             "bls12381_g2_double_events".to_string(),
             self.bls12381_g2_double_events.len(),
         );
-        stats.insert(
-            "blake2s_xor_rotate_right_16_events".to_string(),
-            self.blake2s_xor_rotate_right_16_events.len(),
-        );
-        stats.insert(
-            "blake2s_xor_rotate_16_events".to_string(),
-            self.blake2s_xor_rotate_16_events.len(),
-        );
-
-        stats.insert(
-            "blake2s_add_2_events".to_string(),
-            self.blake2s_add_2_events.len(),
-        );
-
-        stats.insert(
-            "blake2s_add_3_events".to_string(),
-            self.blake2s_add_3_events.len(),
-        );
 
         stats.insert(
-            "blake2s_xor_rotate_right_12_events".to_string(),
-            self.blake2s_xor_rotate_right_12_events.len(),
-        );
-
-        stats.insert(
-            "blake2s_xor_rotate_right_8_events".to_string(),
-            self.blake2s_xor_rotate_right_8_events.len(),
-        );
-
-        stats.insert(
-            "blake2s_xor_rotate_right_7_events".to_string(),
-            self.blake2s_xor_rotate_right_7_events.len(),
-        );
-
-        stats.insert(
-            "blake2s_quarter_round_2x_events".to_string(),
-            self.blake2s_quarter_round_2x_events.len(),
+            "blake2s_round_events".to_string(),
+            self.blake2s_round_events.len(),
         );
 
         stats
@@ -614,23 +526,8 @@ impl MachineRecord for ExecutionRecord {
             .append(&mut other.bls12381_g2_add_events);
         self.bls12381_g2_double_events
             .append(&mut other.bls12381_g2_double_events);
-
-        self.blake2s_xor_rotate_right_16_events
-            .append(&mut other.blake2s_xor_rotate_right_16_events);
-        self.blake2s_xor_rotate_16_events
-            .append(&mut other.blake2s_xor_rotate_16_events);
-        self.blake2s_add_2_events
-            .append(&mut other.blake2s_add_2_events);
-        self.blake2s_add_3_events
-            .append(&mut other.blake2s_add_3_events);
-        self.blake2s_xor_rotate_right_12_events
-            .append(&mut other.blake2s_xor_rotate_right_12_events);
-        self.blake2s_xor_rotate_right_8_events
-            .append(&mut other.blake2s_xor_rotate_right_8_events);
-        self.blake2s_xor_rotate_right_7_events
-            .append(&mut other.blake2s_xor_rotate_right_7_events);
-        self.blake2s_quarter_round_2x_events
-            .append(&mut other.blake2s_quarter_round_2x_events);
+        self.blake2s_round_events
+            .append(&mut other.blake2s_round_events);
 
         // Merge the byte lookups.
         for (shard, events_map) in take(&mut other.byte_lookups) {
@@ -958,53 +855,9 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
-        // blake2s_xor_rotate_right_16 events
-        first.blake2s_xor_rotate_right_16_events =
-            take(&mut self.blake2s_xor_rotate_right_16_events);
-        for (i, event) in first.blake2s_xor_rotate_right_16_events.iter().enumerate() {
-            self.nonce_lookup.insert(event.lookup_id, i as u32);
-        }
-
-        // blake2s_xor_rotate_16 events
-        first.blake2s_xor_rotate_16_events = take(&mut self.blake2s_xor_rotate_16_events);
-        for (i, event) in first.blake2s_xor_rotate_16_events.iter().enumerate() {
-            self.nonce_lookup.insert(event.lookup_id, (i * 48) as u32);
-        }
-
-        // blake2s_add_2 events
-        first.blake2s_add_2_events = take(&mut self.blake2s_add_2_events);
-        for (i, event) in first.blake2s_add_2_events.iter().enumerate() {
-            self.nonce_lookup.insert(event.lookup_id, i as u32);
-        }
-
-        // blake2s_add_3 events
-        first.blake2s_add_3_events = take(&mut self.blake2s_add_3_events);
-        for (i, event) in first.blake2s_add_3_events.iter().enumerate() {
-            self.nonce_lookup.insert(event.lookup_id, i as u32);
-        }
-
-        // blake2s_xor_rotate_right_12 events
-        first.blake2s_xor_rotate_right_12_events =
-            take(&mut self.blake2s_xor_rotate_right_12_events);
-        for (i, event) in first.blake2s_xor_rotate_right_12_events.iter().enumerate() {
-            self.nonce_lookup.insert(event.lookup_id, i as u32);
-        }
-
-        // blake2s_xor_rotate_right_8 events
-        first.blake2s_xor_rotate_right_8_events = take(&mut self.blake2s_xor_rotate_right_8_events);
-        for (i, event) in first.blake2s_xor_rotate_right_8_events.iter().enumerate() {
-            self.nonce_lookup.insert(event.lookup_id, i as u32);
-        }
-
-        // blake2s_xor_rotate_right_7 events
-        first.blake2s_xor_rotate_right_7_events = take(&mut self.blake2s_xor_rotate_right_7_events);
-        for (i, event) in first.blake2s_xor_rotate_right_7_events.iter().enumerate() {
-            self.nonce_lookup.insert(event.lookup_id, i as u32);
-        }
-
-        // blake2s_quarter_round_2x events
-        first.blake2s_quarter_round_2x_events = take(&mut self.blake2s_quarter_round_2x_events);
-        for (i, event) in first.blake2s_quarter_round_2x_events.iter().enumerate() {
+        // blake2s_round events
+        first.blake2s_round_events = take(&mut self.blake2s_round_events);
+        for (i, event) in first.blake2s_round_events.iter().enumerate() {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         }
 
diff --git a/core/src/runtime/syscall.rs b/core/src/runtime/syscall.rs
index 3d2294103..69a9473e1 100644
--- a/core/src/runtime/syscall.rs
+++ b/core/src/runtime/syscall.rs
@@ -6,11 +6,7 @@ use strum_macros::EnumIter;
 
 use crate::runtime::{Register, Runtime};
 use crate::stark::Ed25519Parameters;
-use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sQuarterRound2xChip, Blake2sXorRotate16Chip,
-    Blake2sXorRotateRight12Chip, Blake2sXorRotateRight16Chip, Blake2sXorRotateRight7Chip,
-    Blake2sXorRotateRight8Chip,
-};
+use crate::syscall::precompiles::blake2s::Blake2sRoundChip;
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::bls12_381::g2_add::Bls12381G2AffineAddChip;
 use crate::syscall::precompiles::bls12_381::g2_double::Bls12381G2AffineDoubleChip;
@@ -122,18 +118,7 @@ pub enum SyscallCode {
     /// Executes the `HINT_READ` precompile.
     HINT_READ = 0x00_00_00_F1,
 
-    BLAKE_2S_XOR_ROTATE_RIGHT_16 = 0x00_01_01_CC,
-
-    BLAKE_2S_XOR_ROTATE_16 = 0x00_30_01_CD, // based on sha-extend
-
-    BLAKE_2S_ADD_2 = 0x00_01_01_CE,
-
-    BLAKE_2S_ADD_3 = 0x00_01_01_CF,
-
-    BLAKE_2S_XOR_ROTATE_RIGHT_12 = 0x00_01_01_EA,
-    BLAKE_2S_XOR_ROTATE_RIGHT_8 = 0x00_01_01_EB,
-    BLAKE_2S_XOR_ROTATE_RIGHT_7 = 0x00_01_01_EC,
-    BLAKE_2S_QUARTER_ROUND_2X = 0x00_01_01_ED,
+    BLAKE_2S_ROUND = 0x00_01_01_ED,
 }
 
 impl SyscallCode {
@@ -170,14 +155,7 @@ impl SyscallCode {
             0x00_01_01_F2 => SyscallCode::BLS12381_G1_DECOMPRESS,
             0x00_01_01_80 => SyscallCode::BLS12381_G2_ADD,
             0x00_00_01_81 => SyscallCode::BLS12381_G2_DOUBLE,
-            0x00_01_01_CC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_16,
-            0x00_30_01_CD => SyscallCode::BLAKE_2S_XOR_ROTATE_16,
-            0x00_01_01_CE => SyscallCode::BLAKE_2S_ADD_2,
-            0x00_01_01_CF => SyscallCode::BLAKE_2S_ADD_3,
-            0x00_01_01_EA => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12,
-            0x00_01_01_EB => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8,
-            0x00_01_01_EC => SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7,
-            0x00_01_01_ED => SyscallCode::BLAKE_2S_QUARTER_ROUND_2X,
+            0x00_01_01_ED => SyscallCode::BLAKE_2S_ROUND,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -417,43 +395,8 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
     );
 
     syscall_map.insert(
-        SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_16,
-        Arc::new(Blake2sXorRotateRight16Chip::new()),
-    );
-
-    syscall_map.insert(
-        SyscallCode::BLAKE_2S_XOR_ROTATE_16,
-        Arc::new(Blake2sXorRotate16Chip::new()),
-    );
-
-    syscall_map.insert(
-        SyscallCode::BLAKE_2S_ADD_2,
-        Arc::new(Blake2sAdd2Chip::new()),
-    );
-
-    syscall_map.insert(
-        SyscallCode::BLAKE_2S_ADD_3,
-        Arc::new(Blake2sAdd3Chip::new()),
-    );
-
-    syscall_map.insert(
-        SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12,
-        Arc::new(Blake2sXorRotateRight12Chip::new()),
-    );
-
-    syscall_map.insert(
-        SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8,
-        Arc::new(Blake2sXorRotateRight8Chip::new()),
-    );
-
-    syscall_map.insert(
-        SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7,
-        Arc::new(Blake2sXorRotateRight7Chip::new()),
-    );
-
-    syscall_map.insert(
-        SyscallCode::BLAKE_2S_QUARTER_ROUND_2X,
-        Arc::new(Blake2sQuarterRound2xChip::new()),
+        SyscallCode::BLAKE_2S_ROUND,
+        Arc::new(Blake2sRoundChip::new()),
     );
 
     syscall_map
@@ -569,52 +512,8 @@ mod tests {
                 SyscallCode::BLS12381_G2_DOUBLE => {
                     assert_eq!(code as u32, sphinx_zkvm::syscalls::BLS12381_G2_DOUBLE)
                 }
-
-                SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_16 => {
-                    assert_eq!(
-                        code as u32,
-                        sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_16
-                    )
-                }
-
-                SyscallCode::BLAKE_2S_XOR_ROTATE_16 => {
-                    assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_16)
-                }
-
-                SyscallCode::BLAKE_2S_ADD_2 => {
-                    assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_ADD_2)
-                }
-
-                SyscallCode::BLAKE_2S_ADD_3 => {
-                    assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_ADD_3)
-                }
-
-                SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12 => {
-                    assert_eq!(
-                        code as u32,
-                        sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_12
-                    )
-                }
-
-                SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8 => {
-                    assert_eq!(
-                        code as u32,
-                        sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_8
-                    )
-                }
-
-                SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7 => {
-                    assert_eq!(
-                        code as u32,
-                        sphinx_zkvm::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_7
-                    )
-                }
-
-                SyscallCode::BLAKE_2S_QUARTER_ROUND_2X => {
-                    assert_eq!(
-                        code as u32,
-                        sphinx_zkvm::syscalls::BLAKE_2S_QUARTER_ROUND_2X
-                    )
+                SyscallCode::BLAKE_2S_ROUND => {
+                    assert_eq!(code as u32, sphinx_zkvm::syscalls::BLAKE_2S_ROUND)
                 }
             }
         }
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index cfbc76aaf..3b4d61efc 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -3,11 +3,7 @@ pub use crate::air::SphinxAirBuilder;
 use crate::air::{MachineAir, SPHINX_PROOF_NUM_PV_ELTS};
 use crate::memory::{MemoryChipType, MemoryProgramChip};
 use crate::stark::Chip;
-use crate::syscall::precompiles::blake2s::{
-    Blake2sAdd2Chip, Blake2sAdd3Chip, Blake2sQuarterRound2xChip, Blake2sXorRotate16Chip,
-    Blake2sXorRotateRight12Chip, Blake2sXorRotateRight16Chip, Blake2sXorRotateRight7Chip,
-    Blake2sXorRotateRight8Chip,
-};
+use crate::syscall::precompiles::blake2s::Blake2sRoundChip;
 use crate::syscall::precompiles::bls12_381::g1_decompress::Bls12381G1DecompressChip;
 use crate::syscall::precompiles::field::FieldChip;
 use crate::syscall::precompiles::quad_field::QuadFieldChip;
@@ -111,16 +107,8 @@ pub enum RiscvAir<F: PrimeField32> {
     Bls12381Fp2Op(QuadFieldChip<Bls12381BaseField>),
     /// A precompile for decompressing a point on the BLS12-381 curve.
     Bls12381G1Decompress(Bls12381G1DecompressChip),
-
-    // Blake2s
-    Blake2sXorRotateRight16(Blake2sXorRotateRight16Chip),
-    Blake2sXorRotate16(Blake2sXorRotate16Chip), // based on sha-extend
-    Blake2sAdd2(Blake2sAdd2Chip),
-    Blake2sAdd3(Blake2sAdd3Chip),
-    Blake2sXorRotateRight12(Blake2sXorRotateRight12Chip),
-    Blake2sXorRotateRight8(Blake2sXorRotateRight8Chip),
-    Blake2sXorRotateRight7(Blake2sXorRotateRight7Chip),
-    Blake2sQuarterRound2x(Blake2sQuarterRound2xChip),
+    // A precompile for computing round function of Blake2s algorithm
+    Blake2sRound(Blake2sRoundChip),
 }
 
 impl<F: PrimeField32> RiscvAir<F> {
@@ -196,38 +184,8 @@ impl<F: PrimeField32> RiscvAir<F> {
         chips.push(RiscvAir::ProgramMemory(program_memory_init));
         let byte = ByteChip::default();
         chips.push(RiscvAir::ByteLookup(byte));
-
-        let blake_2s_xor_rotate_right_16 = Blake2sXorRotateRight16Chip::default();
-        chips.push(RiscvAir::Blake2sXorRotateRight16(
-            blake_2s_xor_rotate_right_16,
-        ));
-
-        let blake_2s_xor_rotate_16 = Blake2sXorRotate16Chip::default();
-        chips.push(RiscvAir::Blake2sXorRotate16(blake_2s_xor_rotate_16));
-
-        let blake2s_add_2 = Blake2sAdd2Chip::default();
-        chips.push(RiscvAir::Blake2sAdd2(blake2s_add_2));
-
-        let blake2s_add_3 = Blake2sAdd3Chip::default();
-        chips.push(RiscvAir::Blake2sAdd3(blake2s_add_3));
-
-        let blake_2s_xor_rotate_right_12 = Blake2sXorRotateRight12Chip::default();
-        chips.push(RiscvAir::Blake2sXorRotateRight12(
-            blake_2s_xor_rotate_right_12,
-        ));
-
-        let blake_2s_xor_rotate_right_8 = Blake2sXorRotateRight8Chip::default();
-        chips.push(RiscvAir::Blake2sXorRotateRight8(
-            blake_2s_xor_rotate_right_8,
-        ));
-
-        let blake_2s_xor_rotate_right_7 = Blake2sXorRotateRight7Chip::default();
-        chips.push(RiscvAir::Blake2sXorRotateRight7(
-            blake_2s_xor_rotate_right_7,
-        ));
-
-        let blake_2s_quarter_round_2x = Blake2sQuarterRound2xChip::default();
-        chips.push(RiscvAir::Blake2sQuarterRound2x(blake_2s_quarter_round_2x));
+        let blake_2s_round = Blake2sRoundChip::default();
+        chips.push(RiscvAir::Blake2sRound(blake_2s_round));
 
         chips
     }
diff --git a/core/src/syscall/precompiles/blake2s/add_2.rs b/core/src/syscall/precompiles/blake2s/add_2.rs
deleted file mode 100644
index 98879c26e..000000000
--- a/core/src/syscall/precompiles/blake2s/add_2.rs
+++ /dev/null
@@ -1,368 +0,0 @@
-use crate::bytes::event::ByteRecord;
-use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::Add4Operation;
-use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
-use crate::stark::SphinxAirBuilder;
-use crate::utils::pad_rows;
-use crate::{
-    air::{EventLens, MachineAir, WithEvents},
-    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
-};
-use core::borrow::{Borrow, BorrowMut};
-use p3_air::{Air, AirBuilder, BaseAir};
-use p3_field::{AbstractField, PrimeField32};
-use p3_matrix::dense::RowMajorMatrix;
-use p3_matrix::Matrix;
-use serde::Deserialize;
-use serde::Serialize;
-use sphinx_derive::AlignedBorrow;
-use std::mem::size_of;
-
-#[derive(Default)]
-pub struct Blake2sAdd2Chip;
-
-impl Blake2sAdd2Chip {
-    pub fn new() -> Self {
-        Blake2sAdd2Chip
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Blake2sAdd2Event {
-    pub lookup_id: usize,
-    pub clk: u32,
-    pub shard: u32,
-    pub channel: u32,
-    pub a_ptr: u32,
-    pub b_ptr: u32,
-
-    pub a_reads_writes: Vec<MemoryWriteRecord>,
-    pub b_reads: Vec<MemoryReadRecord>,
-}
-
-impl Syscall for Blake2sAdd2Chip {
-    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
-        let clk_init = ctx.clk;
-        let shard = ctx.current_shard();
-        let lookup_id = ctx.syscall_lookup_id;
-        let channel = ctx.current_channel();
-
-        let a_ptr = arg1;
-        let b_ptr = arg2;
-
-        let a = ctx.slice_unsafe(a_ptr, 4);
-        let (b_reads, b) = ctx.mr_slice(b_ptr, 12);
-
-        let add2 = a
-            .into_iter()
-            .zip(b[0..4].into_iter())
-            .map(|(a, b)| a.wrapping_add(*b))
-            .collect::<Vec<u32>>();
-
-        ctx.clk += 1;
-
-        // Write rotate_right to a_ptr.
-        let a_reads_writes = ctx.mw_slice(a_ptr, add2.as_slice());
-
-        ctx.record_mut()
-            .blake2s_add_2_events
-            .push(Blake2sAdd2Event {
-                lookup_id,
-                clk: clk_init,
-                shard,
-                channel,
-                a_ptr,
-                b_ptr,
-                a_reads_writes,
-                b_reads,
-            });
-
-        None
-    }
-
-    fn num_extra_cycles(&self) -> u32 {
-        1
-    }
-}
-
-#[derive(Debug, Clone, AlignedBorrow)]
-#[repr(C)]
-struct Blake2sAdd2Cols<T> {
-    pub clk: T,
-    pub shard: T,
-    pub channel: T,
-    pub nonce: T,
-    pub is_real: T,
-
-    pub a_ptr: T,
-    pub b_ptr: T,
-
-    pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 12],
-
-    pub add2: [Add4Operation<T>; 4],
-}
-
-impl<T: PrimeField32> BaseAir<T> for Blake2sAdd2Chip {
-    fn width(&self) -> usize {
-        size_of::<Blake2sAdd2Cols<u8>>()
-    }
-}
-
-impl<'a> WithEvents<'a> for Blake2sAdd2Chip {
-    type Events = &'a [Blake2sAdd2Event];
-}
-
-impl<F: PrimeField32> MachineAir<F> for Blake2sAdd2Chip {
-    type Record = ExecutionRecord;
-    type Program = Program;
-
-    fn name(&self) -> String {
-        "Blake2sAdd2Chip".to_string()
-    }
-
-    fn generate_trace<EL: EventLens<Self>>(
-        &self,
-        input: &EL,
-        output: &mut Self::Record,
-    ) -> RowMajorMatrix<F> {
-        let mut rows = vec![];
-        let width = <Blake2sAdd2Chip as BaseAir<F>>::width(self);
-        let mut new_byte_lookup_events = Vec::new();
-        for event in input.events() {
-            let shard = event.shard;
-            let mut row = vec![F::zero(); width];
-            let cols: &mut Blake2sAdd2Cols<F> = row.as_mut_slice().borrow_mut();
-
-            cols.clk = F::from_canonical_u32(event.clk);
-            cols.is_real = F::one();
-            cols.shard = F::from_canonical_u32(event.shard);
-            cols.channel = F::from_canonical_u32(event.channel);
-            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
-            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
-
-            for i in 0..4usize {
-                cols.a[i].populate(
-                    event.channel,
-                    event.a_reads_writes[i],
-                    &mut new_byte_lookup_events,
-                );
-
-                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
-                cols.b[i + 4].populate(
-                    event.channel,
-                    event.b_reads[i + 4],
-                    &mut new_byte_lookup_events,
-                ); // expected to be zero
-                cols.b[i + 8].populate(
-                    event.channel,
-                    event.b_reads[i + 8],
-                    &mut new_byte_lookup_events,
-                ); // expected to be zero
-
-                let a = event.a_reads_writes[i].value;
-                let b = event.b_reads[i].value;
-
-                let add = cols.add2[i].populate(output, shard, event.channel, a, b, 0, 0);
-                assert_eq!(a + b, add);
-            }
-
-            rows.push(row);
-        }
-
-        output.add_byte_lookup_events(new_byte_lookup_events);
-
-        pad_rows(&mut rows, || {
-            let row = vec![F::zero(); width];
-
-            row
-        });
-
-        let mut trace =
-            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
-
-        // Write the nonces to the trace.
-        for i in 0..trace.height() {
-            let cols: &mut Blake2sAdd2Cols<F> =
-                trace.values[i * width..(i + 1) * width].borrow_mut();
-            cols.nonce = F::from_canonical_usize(i);
-        }
-
-        trace
-    }
-
-    fn included(&self, shard: &Self::Record) -> bool {
-        !shard.blake2s_add_2_events.is_empty()
-    }
-}
-
-impl<AB: SphinxAirBuilder> Air<AB> for Blake2sAdd2Chip
-where
-    AB::F: PrimeField32,
-{
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let local = main.row_slice(0);
-        let next = main.row_slice(1);
-        let local: &Blake2sAdd2Cols<AB::Var> = (*local).borrow();
-        let next: &Blake2sAdd2Cols<AB::Var> = (*next).borrow();
-
-        // Constrain the incrementing nonce.
-        builder.when_first_row().assert_zero(local.nonce);
-        builder
-            .when_transition()
-            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
-
-        for i in 0..4usize {
-            // Eval a
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
-                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.a[i],
-                local.is_real,
-            );
-
-            // Eval b [0..4].
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
-                local.is_real,
-            );
-
-            // Eval b[4..8].
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr
-                    + ((AB::F::from_canonical_u32(4) + AB::F::from_canonical_u32(i as u32))
-                        * AB::F::from_canonical_u32(4)),
-                &local.b[i + 4],
-                local.is_real,
-            );
-
-            // Eval b[8..12].
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr
-                    + ((AB::F::from_canonical_u32(8) + AB::F::from_canonical_u32(i as u32))
-                        * AB::F::from_canonical_u32(4)),
-                &local.b[i + 8],
-                local.is_real,
-            );
-
-            Add4Operation::<AB::F>::eval(
-                builder,
-                *local.a[i].value(),
-                *local.b[i].value(),
-                *local.b[i + 4].value(), // zero
-                *local.b[i + 8].value(), // zero
-                local.shard,
-                local.channel,
-                local.is_real,
-                local.add2[i],
-            );
-        }
-
-        builder.receive_syscall(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_ADD_2.syscall_id()),
-            local.a_ptr,
-            local.b_ptr,
-            local.is_real,
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::BLAKE2S_ADD_2_ELF;
-    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
-    use crate::Program;
-
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 12]) -> Program {
-        let mut instructions = vec![];
-        // memory write a
-        for (index, word) in a.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                a_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // memory write b
-        for (index, word) in b.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                b_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // Syscall invocation
-        instructions.push(Instruction::new(
-            Opcode::ADD,
-            5,
-            0,
-            SyscallCode::BLAKE_2S_ADD_2 as u32,
-            false,
-            true,
-        ));
-        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
-        Program::new(instructions, 0, 0)
-    }
-
-    #[test]
-    fn test_blake2s_add_2_precompile() {
-        setup_logger();
-
-        let a_ptr = 100100100;
-        let b_ptr = 200200200;
-        let program = risc_v_program(
-            a_ptr,
-            b_ptr,
-            [200, 300, 400, 500],
-            [10, 20, 30, 40, 0, 0, 0, 0, 0, 0, 0, 0],
-        );
-
-        let (_, memory) = run_test_with_memory_inspection(program);
-        let mut result = vec![];
-        // result is 4 words, written to a_ptr
-        for i in 0..4 {
-            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
-        }
-
-        assert_eq!(result, [210, 320, 430, 540].to_vec());
-    }
-
-    #[test]
-    fn test_blake2s_add_2_program() {
-        setup_logger();
-        let program = Program::from(BLAKE2S_ADD_2_ELF);
-        run_test(program).unwrap();
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/add_3.rs b/core/src/syscall/precompiles/blake2s/add_3.rs
deleted file mode 100644
index 28506205f..000000000
--- a/core/src/syscall/precompiles/blake2s/add_3.rs
+++ /dev/null
@@ -1,371 +0,0 @@
-use crate::bytes::event::ByteRecord;
-use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::Add4Operation;
-use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
-use crate::stark::SphinxAirBuilder;
-use crate::utils::pad_rows;
-use crate::{
-    air::{EventLens, MachineAir, WithEvents},
-    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
-};
-use core::borrow::{Borrow, BorrowMut};
-use p3_air::{Air, AirBuilder, BaseAir};
-use p3_field::{AbstractField, PrimeField32};
-use p3_matrix::dense::RowMajorMatrix;
-use p3_matrix::Matrix;
-use serde::Deserialize;
-use serde::Serialize;
-use sphinx_derive::AlignedBorrow;
-use std::mem::size_of;
-
-#[derive(Default)]
-pub struct Blake2sAdd3Chip;
-
-impl Blake2sAdd3Chip {
-    pub fn new() -> Self {
-        Blake2sAdd3Chip
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Blake2sAdd3Event {
-    pub lookup_id: usize,
-    pub clk: u32,
-    pub shard: u32,
-    pub channel: u32,
-    pub a_ptr: u32,
-    pub b_ptr: u32,
-
-    pub a_reads_writes: Vec<MemoryWriteRecord>,
-    pub b_reads: Vec<MemoryReadRecord>,
-}
-
-impl Syscall for Blake2sAdd3Chip {
-    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
-        let clk_init = ctx.clk;
-        let shard = ctx.current_shard();
-        let lookup_id = ctx.syscall_lookup_id;
-        let channel = ctx.current_channel();
-
-        let a_ptr = arg1;
-        let b_ptr = arg2;
-
-        let a = ctx.slice_unsafe(a_ptr, 4);
-        let (b_reads, b) = ctx.mr_slice(b_ptr, 12);
-        let c = b[4..8].to_vec();
-
-        let add3 = a
-            .into_iter()
-            .zip(b[0..4].into_iter())
-            .zip(c.into_iter())
-            .map(|((a, b), c)| a.wrapping_add(*b).wrapping_add(c))
-            .collect::<Vec<u32>>();
-
-        ctx.clk += 1;
-
-        // Write rotate_right to a_ptr.
-        let a_reads_writes = ctx.mw_slice(a_ptr, add3.as_slice());
-
-        ctx.record_mut()
-            .blake2s_add_3_events
-            .push(Blake2sAdd3Event {
-                lookup_id,
-                clk: clk_init,
-                shard,
-                channel,
-                a_ptr,
-                b_ptr,
-                a_reads_writes,
-                b_reads,
-            });
-
-        None
-    }
-
-    fn num_extra_cycles(&self) -> u32 {
-        1
-    }
-}
-
-#[derive(Debug, Clone, AlignedBorrow)]
-#[repr(C)]
-struct Blake2sAdd3Cols<T> {
-    pub clk: T,
-    pub shard: T,
-    pub channel: T,
-    pub nonce: T,
-    pub is_real: T,
-
-    pub a_ptr: T,
-    pub b_ptr: T,
-
-    pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 12],
-
-    pub add3: [Add4Operation<T>; 4],
-}
-
-impl<T: PrimeField32> BaseAir<T> for Blake2sAdd3Chip {
-    fn width(&self) -> usize {
-        size_of::<Blake2sAdd3Cols<u8>>()
-    }
-}
-
-impl<'a> WithEvents<'a> for Blake2sAdd3Chip {
-    type Events = &'a [Blake2sAdd3Event];
-}
-
-impl<F: PrimeField32> MachineAir<F> for Blake2sAdd3Chip {
-    type Record = ExecutionRecord;
-    type Program = Program;
-
-    fn name(&self) -> String {
-        "Blake2sAdd3Chip".to_string()
-    }
-
-    fn generate_trace<EL: EventLens<Self>>(
-        &self,
-        input: &EL,
-        output: &mut Self::Record,
-    ) -> RowMajorMatrix<F> {
-        let mut rows = vec![];
-        let width = <Blake2sAdd3Chip as BaseAir<F>>::width(self);
-        let mut new_byte_lookup_events = Vec::new();
-        for event in input.events() {
-            let shard = event.shard;
-            let mut row = vec![F::zero(); width];
-            let cols: &mut Blake2sAdd3Cols<F> = row.as_mut_slice().borrow_mut();
-
-            cols.clk = F::from_canonical_u32(event.clk);
-            cols.is_real = F::one();
-            cols.shard = F::from_canonical_u32(event.shard);
-            cols.channel = F::from_canonical_u32(event.channel);
-            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
-            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
-
-            for i in 0..4usize {
-                cols.a[i].populate(
-                    event.channel,
-                    event.a_reads_writes[i],
-                    &mut new_byte_lookup_events,
-                );
-
-                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
-                cols.b[i + 4].populate(
-                    event.channel,
-                    event.b_reads[i + 4],
-                    &mut new_byte_lookup_events,
-                );
-                cols.b[i + 8].populate(
-                    event.channel,
-                    event.b_reads[i + 8],
-                    &mut new_byte_lookup_events,
-                );
-
-                let a = event.a_reads_writes[i].value;
-                let b = event.b_reads[i].value;
-                let c = event.b_reads[i + 4].value;
-
-                let add = cols.add3[i].populate(output, shard, event.channel, a, b, c, 0);
-                assert_eq!(a + b + c, add);
-            }
-
-            rows.push(row);
-        }
-
-        output.add_byte_lookup_events(new_byte_lookup_events);
-
-        pad_rows(&mut rows, || {
-            let row = vec![F::zero(); width];
-
-            row
-        });
-
-        let mut trace =
-            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
-
-        // Write the nonces to the trace.
-        for i in 0..trace.height() {
-            let cols: &mut Blake2sAdd3Cols<F> =
-                trace.values[i * width..(i + 1) * width].borrow_mut();
-            cols.nonce = F::from_canonical_usize(i);
-        }
-
-        trace
-    }
-
-    fn included(&self, shard: &Self::Record) -> bool {
-        !shard.blake2s_add_3_events.is_empty()
-    }
-}
-
-impl<AB: SphinxAirBuilder> Air<AB> for Blake2sAdd3Chip
-where
-    AB::F: PrimeField32,
-{
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let local = main.row_slice(0);
-        let next = main.row_slice(1);
-        let local: &Blake2sAdd3Cols<AB::Var> = (*local).borrow();
-        let next: &Blake2sAdd3Cols<AB::Var> = (*next).borrow();
-
-        // Constrain the incrementing nonce.
-        builder.when_first_row().assert_zero(local.nonce);
-        builder
-            .when_transition()
-            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
-
-        for i in 0..4usize {
-            // Eval a
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
-                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.a[i],
-                local.is_real,
-            );
-
-            // Eval b[0..4].
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
-                local.is_real,
-            );
-
-            // Eval b[4..8].
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr
-                    + ((AB::F::from_canonical_u32(4) + AB::F::from_canonical_u32(i as u32))
-                        * AB::F::from_canonical_u32(4)),
-                &local.b[i + 4],
-                local.is_real,
-            );
-
-            // Eval b[8..12].
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr
-                    + ((AB::F::from_canonical_u32(8) + AB::F::from_canonical_u32(i as u32))
-                        * AB::F::from_canonical_u32(4)),
-                &local.b[i + 8],
-                local.is_real,
-            );
-
-            Add4Operation::<AB::F>::eval(
-                builder,
-                *local.a[i].value(),
-                *local.b[i].value(),
-                *local.b[i + 4].value(),
-                *local.b[i + 8].value(), // zero
-                local.shard,
-                local.channel,
-                local.is_real,
-                local.add3[i],
-            );
-        }
-
-        builder.receive_syscall(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_ADD_3.syscall_id()),
-            local.a_ptr,
-            local.b_ptr,
-            local.is_real,
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::BLAKE2S_ADD_3_ELF;
-    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
-    use crate::Program;
-
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 12]) -> Program {
-        let mut instructions = vec![];
-        // memory write a
-        for (index, word) in a.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                a_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // memory write b
-        for (index, word) in b.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                b_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // Syscall invocation
-        instructions.push(Instruction::new(
-            Opcode::ADD,
-            5,
-            0,
-            SyscallCode::BLAKE_2S_ADD_3 as u32,
-            false,
-            true,
-        ));
-        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
-        Program::new(instructions, 0, 0)
-    }
-
-    #[test]
-    fn test_blake2s_add_3_precompile() {
-        setup_logger();
-
-        let a_ptr = 100100100;
-        let b_ptr = 200200200;
-        let program = risc_v_program(
-            a_ptr,
-            b_ptr,
-            [200, 300, 400, 500],
-            [10, 20, 30, 40, 1, 2, 3, 4, 0, 0, 0, 0],
-        );
-
-        let (_, memory) = run_test_with_memory_inspection(program);
-        let mut result = vec![];
-        // result is 4 words, written to a_ptr
-        for i in 0..4 {
-            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
-        }
-
-        assert_eq!(result, [211, 322, 433, 544].to_vec());
-    }
-
-    #[test]
-    fn test_blake2s_add_3_program() {
-        setup_logger();
-        let program = Program::from(BLAKE2S_ADD_3_ELF);
-        run_test(program).unwrap();
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 83844f82c..a9229b40b 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -1,103 +1,112 @@
-mod add_2;
-mod add_3;
 mod round;
-mod xor_rotate_16; // based on sha-extend
-mod xor_rotate_right_12;
-mod xor_rotate_right_16;
-mod xor_rotate_right_7;
-mod xor_rotate_right_8;
-
-pub use add_2::*;
-pub use add_3::*;
 pub use round::*;
-pub use xor_rotate_16::*; // based on sha-extend
-pub use xor_rotate_right_12::*;
-pub use xor_rotate_right_16::*;
-pub use xor_rotate_right_7::*;
-pub use xor_rotate_right_8::*;
-
-#[cfg(test)]
-mod tests {
-    fn xor_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
-        [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]]
-    }
-
-    fn shuffle_left_1_u32x4(a: [u32; 4]) -> [u32; 4] {
-        [a[1], a[2], a[3], a[0]]
-    }
-
-    fn shuffle_left_2_u32x4(a: [u32; 4]) -> [u32; 4] {
-        [a[2], a[3], a[0], a[1]]
-    }
-
-    fn shuffle_left_3_u32x4(a: [u32; 4]) -> [u32; 4] {
-        [a[3], a[0], a[1], a[2]]
-    }
-
-    fn shuffle_right_1_u32x4(a: [u32; 4]) -> [u32; 4] {
-        shuffle_left_3_u32x4(a)
-    }
-    fn shuffle_right_2_u32x4(a: [u32; 4]) -> [u32; 4] {
-        shuffle_left_2_u32x4(a)
-    }
-    fn shuffle_right_3_u32x4(a: [u32; 4]) -> [u32; 4] {
-        shuffle_left_1_u32x4(a)
-    }
-
-    fn wrapping_add_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
-        [
-            a[0].wrapping_add(b[0]),
-            a[1].wrapping_add(b[1]),
-            a[2].wrapping_add(b[2]),
-            a[3].wrapping_add(b[3]),
-        ]
-    }
-
-    fn rotate_right_const(a: [u32; 4], n: u32) -> [u32; 4] {
-        [
-            a[0].rotate_right(n),
-            a[1].rotate_right(n),
-            a[2].rotate_right(n),
-            a[3].rotate_right(n),
-        ]
-    }
 
-    fn quarter_round(v: &mut Vec<[u32; 4]>, rd: u32, rb: u32, m: [u32; 4]) {
-        v[0] = wrapping_add_u32x4(wrapping_add_u32x4(v[0], v[1]), m); // m.from_le (?)
-        v[3] = rotate_right_const(xor_u32x4(v[3], v[0]), rd);
-        v[2] = wrapping_add_u32x4(v[2], v[3]);
-        v[1] = rotate_right_const(xor_u32x4(v[1], v[2]), rb);
-    }
-
-    fn shuffle(v: &mut Vec<[u32; 4]>) {
-        v[1] = shuffle_left_1_u32x4(v[1]);
-        v[2] = shuffle_left_2_u32x4(v[2]);
-        v[3] = shuffle_left_3_u32x4(v[3]);
-    }
-
-    fn unshuffle(v: &mut Vec<[u32; 4]>) {
-        v[1] = shuffle_right_1_u32x4(v[1]);
-        v[2] = shuffle_right_2_u32x4(v[2]);
-        v[3] = shuffle_right_3_u32x4(v[3]);
-    }
+fn xor_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
+    [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]]
+}
+fn shuffle_left_1_u32x4(a: [u32; 4]) -> [u32; 4] {
+    [a[1], a[2], a[3], a[0]]
+}
+fn shuffle_left_2_u32x4(a: [u32; 4]) -> [u32; 4] {
+    [a[2], a[3], a[0], a[1]]
+}
+fn shuffle_left_3_u32x4(a: [u32; 4]) -> [u32; 4] {
+    [a[3], a[0], a[1], a[2]]
+}
+fn shuffle_right_1_u32x4(a: [u32; 4]) -> [u32; 4] {
+    shuffle_left_3_u32x4(a)
+}
+fn shuffle_right_2_u32x4(a: [u32; 4]) -> [u32; 4] {
+    shuffle_left_2_u32x4(a)
+}
+fn shuffle_right_3_u32x4(a: [u32; 4]) -> [u32; 4] {
+    shuffle_left_1_u32x4(a)
+}
+fn wrapping_add_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
+    [
+        a[0].wrapping_add(b[0]),
+        a[1].wrapping_add(b[1]),
+        a[2].wrapping_add(b[2]),
+        a[3].wrapping_add(b[3]),
+    ]
+}
+fn rotate_right_const(a: [u32; 4], n: u32) -> [u32; 4] {
+    [
+        a[0].rotate_right(n),
+        a[1].rotate_right(n),
+        a[2].rotate_right(n),
+        a[3].rotate_right(n),
+    ]
+}
+fn quarter_round(v: &mut Vec<[u32; 4]>, rd: u32, rb: u32, m: [u32; 4]) {
+    v[0] = wrapping_add_u32x4(wrapping_add_u32x4(v[0], v[1]), m); // m.from_le (?)
+    v[3] = rotate_right_const(xor_u32x4(v[3], v[0]), rd);
+    v[2] = wrapping_add_u32x4(v[2], v[3]);
+    v[1] = rotate_right_const(xor_u32x4(v[1], v[2]), rb);
+}
+fn shuffle(v: &mut Vec<[u32; 4]>) {
+    v[1] = shuffle_left_1_u32x4(v[1]);
+    v[2] = shuffle_left_2_u32x4(v[2]);
+    v[3] = shuffle_left_3_u32x4(v[3]);
+}
+fn unshuffle(v: &mut Vec<[u32; 4]>) {
+    v[1] = shuffle_right_1_u32x4(v[1]);
+    v[2] = shuffle_right_2_u32x4(v[2]);
+    v[3] = shuffle_right_3_u32x4(v[3]);
+}
+fn gather(m: [u32; 16], i0: usize, i1: usize, i2: usize, i3: usize) -> [u32; 4] {
+    [m[i0], m[i1], m[i2], m[i3]]
+}
+fn round(v: &mut Vec<[u32; 4]>, m: [u32; 16], s: [usize; 16]) {
+    let r1 = 16;
+    let r2 = 12;
+    let r3 = 8;
+    let r4 = 7;
+
+    quarter_round(v, r1, r2, gather(m, s[0], s[2], s[4], s[6]));
+    quarter_round(v, r3, r4, gather(m, s[1], s[3], s[5], s[7]));
+    shuffle(v);
+    quarter_round(v, r1, r2, gather(m, s[8], s[10], s[12], s[14]));
+    quarter_round(v, r3, r4, gather(m, s[9], s[11], s[13], s[15]));
+    unshuffle(v);
+}
 
-    fn gather(m: [u32; 16], i0: usize, i1: usize, i2: usize, i3: usize) -> [u32; 4] {
-        [m[i0], m[i1], m[i2], m[i3]]
+pub fn blake2s_round(v: &mut [u32], m: &[u32]) {
+    assert_eq!(v.len(), 16);
+    assert_eq!(m.len(), 24);
+    for item in m[16..24].iter() {
+        assert_eq!(*item, 0u32);
     }
 
-    fn round(v: &mut Vec<[u32; 4]>, m: [u32; 16], s: [usize; 16]) {
-        let r1 = 16;
-        let r2 = 12;
-        let r3 = 8;
-        let r4 = 7;
+    let r1 = 16;
+    let r2 = 12;
+    let r3 = 8;
+    let r4 = 7;
+
+    let mut v0 = [0u32; 4];
+    v0.copy_from_slice(&v[0..4]);
+    let mut v1 = [0u32; 4];
+    v1.copy_from_slice(&v[4..8]);
+    let mut v2 = [0u32; 4];
+    v2.copy_from_slice(&v[8..12]);
+    let mut v3 = [0u32; 4];
+    v3.copy_from_slice(&v[12..16]);
+
+    let mut input = vec![v0, v1, v2, v3];
+    quarter_round(&mut input, r1, r2, m[0..4].try_into().unwrap());
+    quarter_round(&mut input, r3, r4, m[4..8].try_into().unwrap());
+    shuffle(&mut input);
+    quarter_round(&mut input, r1, r2, m[8..12].try_into().unwrap());
+    quarter_round(&mut input, r3, r4, m[12..16].try_into().unwrap());
+    unshuffle(&mut input);
+
+    let input = input.into_iter().flatten().collect::<Vec<u32>>();
+    v.copy_from_slice(input.as_slice());
+}
 
-        quarter_round(v, r1, r2, gather(m, s[0], s[2], s[4], s[6]));
-        quarter_round(v, r3, r4, gather(m, s[1], s[3], s[5], s[7]));
-        shuffle(v);
-        quarter_round(v, r1, r2, gather(m, s[8], s[10], s[12], s[14]));
-        quarter_round(v, r3, r4, gather(m, s[9], s[11], s[13], s[15]));
-        unshuffle(v);
-    }
+#[cfg(test)]
+mod tests {
+    use crate::syscall::precompiles::blake2s::{quarter_round, round, shuffle, unshuffle};
 
     #[test]
     fn test_blake2s_round_function() {
@@ -257,124 +266,4 @@ mod tests {
             vec![0x6ab9ed19, 0x7f9dcd68, 0xeb49bb8e, 0xf4a5ad0]
         );
     }
-
-    #[test]
-    fn test_blake2s_quarter_round_2x_function() {
-        let mut v: Vec<[u32; 4]> = vec![
-            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
-            [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0xe07c2654, 0x5be0cd19],
-        ];
-        let m = [0, 0, 0, 0];
-        let rd = 16;
-        let rb = 12;
-
-        quarter_round(&mut v, rd, rb, m);
-
-        let rd = 8;
-        let rb = 7;
-
-        quarter_round(&mut v, rd, rb, m);
-
-        assert_eq!(
-            v[0].to_vec(),
-            vec![0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc]
-        );
-        assert_eq!(
-            v[1].to_vec(),
-            vec![0x408705aa, 0x8d07c52d, 0xb9d6aa3a, 0x88609304]
-        );
-        assert_eq!(
-            v[2].to_vec(),
-            vec![0x5c7a89f8, 0xb5f896c7, 0x81e69eeb, 0xe17775ed]
-        );
-        assert_eq!(
-            v[3].to_vec(),
-            vec![0x87b6b678, 0x7af31ada, 0x5a2defeb, 0x2cdd25e3]
-        );
-    }
-
-    #[test]
-    fn test_blake2s_quarter_round_2x_shuffle_function() {
-        let mut v: Vec<[u32; 4]> = vec![
-            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
-            [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0xe07c2654, 0x5be0cd19],
-        ];
-        let m = [0, 0, 0, 0];
-        let rd = 16;
-        let rb = 12;
-
-        quarter_round(&mut v, rd, rb, m);
-
-        let rd = 8;
-        let rb = 7;
-
-        quarter_round(&mut v, rd, rb, m);
-        shuffle(&mut v);
-
-        assert_eq!(
-            v[0].to_vec(),
-            vec![0xdc0f959e, 0x8c871712, 0xc6a650d4, 0xd26fb9fc]
-        );
-        assert_eq!(
-            v[1].to_vec(),
-            vec![0x8d07c52d, 0xb9d6aa3a, 0x88609304, 0x408705aa]
-        );
-        assert_eq!(
-            v[2].to_vec(),
-            vec![0x81e69eeb, 0xe17775ed, 0x5c7a89f8, 0xb5f896c7]
-        );
-        assert_eq!(
-            v[3].to_vec(),
-            vec![0x2cdd25e3, 0x87b6b678, 0x7af31ada, 0x5a2defeb]
-        );
-    }
-
-    #[test]
-    fn test_blake2s_quarter_round_2x_shuffle_quarter_round_2x_function() {
-        let mut v: Vec<[u32; 4]> = vec![
-            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
-            [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0xe07c2654, 0x5be0cd19],
-        ];
-        let m = [0, 0, 0, 0];
-        let rd = 16;
-        let rb = 12;
-        quarter_round(&mut v, rd, rb, m);
-
-        let rd = 8;
-        let rb = 7;
-        quarter_round(&mut v, rd, rb, m);
-        shuffle(&mut v);
-
-        let rd = 16;
-        let rb = 12;
-        quarter_round(&mut v, rd, rb, m);
-
-        let rd = 8;
-        let rb = 7;
-        quarter_round(&mut v, rd, rb, m);
-        unshuffle(&mut v);
-
-        assert_eq!(
-            v[0].to_vec(),
-            vec![0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3]
-        );
-        assert_eq!(
-            v[1].to_vec(),
-            vec![0x515f5af4, 0x301095b, 0xb151a3c2, 0x5e17f96f]
-        );
-        assert_eq!(
-            v[2].to_vec(),
-            vec![0xc561666d, 0xf291605, 0x990c6d13, 0x76fff6f1]
-        );
-        assert_eq!(
-            v[3].to_vec(),
-            vec![0x1e53bf19, 0x6fe4a680, 0x8e33663, 0x97fd885e]
-        );
-    }
 }
diff --git a/core/src/syscall/precompiles/blake2s/round.rs b/core/src/syscall/precompiles/blake2s/round.rs
index 834f597c4..2661514cc 100644
--- a/core/src/syscall/precompiles/blake2s/round.rs
+++ b/core/src/syscall/precompiles/blake2s/round.rs
@@ -24,13 +24,13 @@ const R_3: u32 = 8;
 const R_4: u32 = 7;
 
 #[derive(Default)]
-pub struct Blake2sQuarterRound2xChip;
+pub struct Blake2sRoundChip;
 
-impl Blake2sQuarterRound2xChip {
+impl Blake2sRoundChip {
     pub fn new() -> Self {
-        Blake2sQuarterRound2xChip
+        Blake2sRoundChip
     }
-    pub fn constrain_shuffled_unshuffled_indices<AB: SphinxAirBuilder>(
+    pub fn constrain_shuffled_indices<AB: SphinxAirBuilder>(
         &self,
         builder: &mut AB,
         indices: &[AB::Var],
@@ -50,7 +50,7 @@ impl Blake2sQuarterRound2xChip {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Blake2sQuarterRound2xEvent {
+pub struct Blake2sRoundEvent {
     pub lookup_id: usize,
     pub clk: u32,
     pub shard: u32,
@@ -62,7 +62,7 @@ pub struct Blake2sQuarterRound2xEvent {
     pub b_reads: Vec<MemoryReadRecord>,
 }
 
-impl Syscall for Blake2sQuarterRound2xChip {
+impl Syscall for Blake2sRoundChip {
     fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
         let clk_init = ctx.clk;
         let shard = ctx.current_shard();
@@ -80,6 +80,14 @@ impl Syscall for Blake2sQuarterRound2xChip {
         //    m3[0] || m3[1] || m3[2] || m3[3] || m4[0] || m4[1] || m4[2] || mr[3] ||
         //    0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
         let (b_reads, b) = ctx.mr_slice(b_ptr, 24);
+        assert_eq!(b[16], 0u32);
+        assert_eq!(b[17], 0u32);
+        assert_eq!(b[18], 0u32);
+        assert_eq!(b[19], 0u32);
+        assert_eq!(b[20], 0u32);
+        assert_eq!(b[21], 0u32);
+        assert_eq!(b[22], 0u32);
+        assert_eq!(b[23], 0u32);
 
         // 1x (m1, R1, R2)
         // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m1)
@@ -237,8 +245,8 @@ impl Syscall for Blake2sQuarterRound2xChip {
         let a_reads_writes = ctx.mw_slice(a_ptr, a.as_slice());
 
         ctx.record_mut()
-            .blake2s_quarter_round_2x_events
-            .push(Blake2sQuarterRound2xEvent {
+            .blake2s_round_events
+            .push(Blake2sRoundEvent {
                 lookup_id,
                 clk: clk_init,
                 shard,
@@ -259,7 +267,7 @@ impl Syscall for Blake2sQuarterRound2xChip {
 
 #[derive(Debug, Clone, AlignedBorrow)]
 #[repr(C)]
-struct Blake2sQuarterRound2xCols<T> {
+struct Blake2sRoundCols<T> {
     pub clk: T,
     pub shard: T,
     pub channel: T,
@@ -270,7 +278,6 @@ struct Blake2sQuarterRound2xCols<T> {
     pub b_ptr: T,
 
     pub shuffled_indices: [T; 16],
-    pub unshuffled_indices: [T; 16],
 
     pub a: [MemoryWriteCols<T>; 16],
     pub b: [MemoryReadCols<T>; 24],
@@ -280,22 +287,22 @@ struct Blake2sQuarterRound2xCols<T> {
     pub rotate_right: [FixedRotateRightOperation<T>; 32],
 }
 
-impl<T: PrimeField32> BaseAir<T> for Blake2sQuarterRound2xChip {
+impl<T: PrimeField32> BaseAir<T> for Blake2sRoundChip {
     fn width(&self) -> usize {
-        size_of::<Blake2sQuarterRound2xCols<u8>>()
+        size_of::<Blake2sRoundCols<u8>>()
     }
 }
 
-impl<'a> WithEvents<'a> for Blake2sQuarterRound2xChip {
-    type Events = &'a [Blake2sQuarterRound2xEvent];
+impl<'a> WithEvents<'a> for Blake2sRoundChip {
+    type Events = &'a [Blake2sRoundEvent];
 }
 
-impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
+impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
     type Record = ExecutionRecord;
     type Program = Program;
 
     fn name(&self) -> String {
-        "Blake2sQuarterRound2xChip".to_string()
+        "Blake2sRoundChip".to_string()
     }
 
     fn generate_trace<EL: EventLens<Self>>(
@@ -304,12 +311,12 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
         output: &mut Self::Record,
     ) -> RowMajorMatrix<F> {
         let mut rows = vec![];
-        let width = <Blake2sQuarterRound2xChip as BaseAir<F>>::width(self);
+        let width = <Blake2sRoundChip as BaseAir<F>>::width(self);
         let mut new_byte_lookup_events = Vec::new();
         for event in input.events() {
             let shard = event.shard;
             let mut row = vec![F::zero(); width];
-            let cols: &mut Blake2sQuarterRound2xCols<F> = row.as_mut_slice().borrow_mut();
+            let cols: &mut Blake2sRoundCols<F> = row.as_mut_slice().borrow_mut();
 
             cols.clk = F::from_canonical_u32(event.clk);
             cols.is_real = F::one();
@@ -333,27 +340,20 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
             }
 
-            let v1_shuffle_lookup = vec![1, 2, 3, 0];
-            let v2_shuffle_lookup = vec![2, 3, 0, 1];
-            let v3_shuffle_lookup = vec![3, 0, 1, 2];
-
-            let v1_unshuffle_lookup = v1_shuffle_lookup.clone();
-            let v2_unshuffle_lookup = v2_shuffle_lookup.clone();
-            let v3_unshuffle_lookup = v3_shuffle_lookup.clone();
+            let mut v0_outer = vec![0u32; 4];
+            let mut v1_outer = vec![0u32; 4];
+            let mut v2_outer = vec![0u32; 4];
+            let mut v3_outer = vec![0u32; 4];
 
+            // 1x (m1, R1, R2)
             for i in 0..4usize {
-                // 1x (m1, R1, R2)
-                let v0 = event.a_reads_writes[i].value;
-                let v1 = event.a_reads_writes[i + 4].value;
-                let v2 = event.a_reads_writes[i + 8].value;
-                let v3 = event.a_reads_writes[i + 12].value;
+                let v0 = event.a_reads_writes[i].prev_value;
+                let v1 = event.a_reads_writes[i + 4].prev_value;
+                let v2 = event.a_reads_writes[i + 8].prev_value;
+                let v3 = event.a_reads_writes[i + 12].prev_value;
                 let m1 = event.b_reads[i].value;
-                let m2 = event.b_reads[i + 4].value;
-                let m3 = event.b_reads[i + 8].value;
-                let m4 = event.b_reads[i + 12].value;
                 let zero1 = event.b_reads[i + 16].value;
                 let zero2 = event.b_reads[i + 20].value;
-
                 assert_eq!(zero1, 0);
                 assert_eq!(zero2, 0);
 
@@ -362,18 +362,25 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 assert_eq!(v0 + v1 + m1 + zero1, v0_new);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-                let temp = cols.xor[i].populate(output, shard, event.channel, v3, v0);
+                let temp = cols.xor[i].populate(output, shard, event.channel, v3, v0_new);
                 let v3_new =
                     cols.rotate_right[i].populate(output, shard, event.channel, temp, R_1 as usize);
-                assert_eq!((v3 ^ v0).rotate_right(R_1), v3_new);
+                assert_eq!((v3 ^ v0_new).rotate_right(R_1), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                let v2_new =
-                    cols.add[i + 4].populate(output, shard, event.channel, v2, v3, zero1, zero2);
-                assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
+                let v2_new = cols.add[i + 4].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    v2,
+                    v3_new,
+                    zero1,
+                    zero2,
+                );
+                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-                let temp = cols.xor[i + 4].populate(output, shard, event.channel, v1, v2);
+                let temp = cols.xor[i + 4].populate(output, shard, event.channel, v1, v2_new);
                 let v1_new = cols.rotate_right[i + 4].populate(
                     output,
                     shard,
@@ -381,64 +388,107 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                     temp,
                     R_2 as usize,
                 );
-                assert_eq!((v1 ^ v2).rotate_right(R_2), v1_new);
+                assert_eq!((v1 ^ v2_new).rotate_right(R_2), v1_new);
+
+                v0_outer[i] = v0_new;
+                v1_outer[i] = v1_new;
+                v2_outer[i] = v2_new;
+                v3_outer[i] = v3_new;
+            }
 
-                // 2x (m2, R3, R4)
-                let v0 = v0_new;
-                let v1 = v1_new;
-                let v2 = v2_new;
-                let v3 = v3_new;
+            // 2x (m2, R3, R4)
+            for i in 0..4usize {
+                let v0 = v0_outer[i];
+                let v1 = v1_outer[i];
+                let v2 = v2_outer[i];
+                let v3 = v3_outer[i];
+                let m2 = event.b_reads[i + 4].value;
+                let zero1 = event.b_reads[i + 16].value;
+                let zero2 = event.b_reads[i + 20].value;
+                assert_eq!(zero1, 0);
+                assert_eq!(zero2, 0);
 
                 // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
                 let v0_new =
                     cols.add[i + 8].populate(output, shard, event.channel, v0, v1, m2, zero1);
-                assert_eq!(v0 + v1 + m1 + zero1, v0_new);
+                assert_eq!(v0 + v1 + m2 + zero1, v0_new);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
-                cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
-                let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0);
-                let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
-                    //let v3_new = cols.rotate_right[i + 8].populate(
+                //cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
+                let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0_new);
+                //let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
+                let v3_new = cols.rotate_right[i + 8].populate(
                     output,
                     shard,
                     event.channel,
                     temp,
                     R_3 as usize,
                 );
-                assert_eq!((v3 ^ v0).rotate_right(R_3), v3_new);
+                assert_eq!((v3 ^ v0_new).rotate_right(R_3), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
-                let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
-                    //let v2_new = cols.add[i + 4 + 8].populate(
+                //cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
+                //let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
+                let v2_new = cols.add[i + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
                     v2,
-                    v3,
+                    v3_new,
                     zero1,
                     zero2,
                 );
-                assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
+                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
-                cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
-                let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2);
-                let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
-                    //let v1_new = cols.rotate_right[i + 4 + 8].populate(
+                //cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
+                let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2_new);
+                //let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
+                let v1_new = cols.rotate_right[i + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
                     temp,
                     R_4 as usize,
                 );
-                assert_eq!((v1 ^ v2).rotate_right(R_4), v1_new);
+                assert_eq!((v1 ^ v2_new).rotate_right(R_4), v1_new);
+
+                v0_outer[i] = v0_new;
+                v1_outer[i] = v1_new;
+                v2_outer[i] = v2_new;
+                v3_outer[i] = v3_new;
+            }
 
-                // 3x (m3, R1, R2)
-                let v0 = v0_new;
-                let v1 = v1_new;
-                let v2 = v2_new;
-                let v3 = v3_new;
+            // shuffle
+            // v[1]
+            v1_outer.swap(0, 3);
+            v1_outer.swap(0, 1);
+            v1_outer.swap(1, 2);
+
+            // v[2]
+            v2_outer.swap(0, 2);
+            v2_outer.swap(1, 3);
+
+            // v[3]
+            v3_outer.swap(2, 3);
+            v3_outer.swap(1, 2);
+            v3_outer.swap(0, 1);
+
+            // 3x (m3, R1, R2)
+            for i in 0..4usize {
+                cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
+                cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
+                cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
+
+                let v0 = v0_outer[i];
+                let v1 = v1_outer[i];
+                let v2 = v2_outer[i];
+                let v3 = v3_outer[i];
+                let m3 = event.b_reads[i + 8].value;
+                let zero1 = event.b_reads[i + 16].value;
+                let zero2 = event.b_reads[i + 20].value;
+                assert_eq!(zero1, 0);
+                assert_eq!(zero2, 0);
 
                 // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
                 let v0_new =
@@ -446,7 +496,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 assert_eq!(v0 + v1 + m3 + zero1, v0_new);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-                let temp = cols.xor[i + 16].populate(output, shard, event.channel, v3, v0);
+                let temp = cols.xor[i + 16].populate(output, shard, event.channel, v3, v0_new);
                 let v3_new = cols.rotate_right[i + 16].populate(
                     output,
                     shard,
@@ -454,7 +504,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                     temp,
                     R_1 as usize,
                 );
-                assert_eq!((v3 ^ v0).rotate_right(R_1), v3_new);
+                assert_eq!((v3 ^ v0_new).rotate_right(R_1), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
                 let v2_new = cols.add[i + 16 + 4].populate(
@@ -462,14 +512,14 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                     shard,
                     event.channel,
                     v2,
-                    v3,
+                    v3_new,
                     zero1,
                     zero2,
                 );
-                assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
+                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-                let temp = cols.xor[i + 16 + 4].populate(output, shard, event.channel, v1, v2);
+                let temp = cols.xor[i + 16 + 4].populate(output, shard, event.channel, v1, v2_new);
                 let v1_new = cols.rotate_right[i + 16 + 4].populate(
                     output,
                     shard,
@@ -477,13 +527,25 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                     temp,
                     R_2 as usize,
                 );
-                assert_eq!((v1 ^ v2).rotate_right(R_2), v1_new);
+                assert_eq!((v1 ^ v2_new).rotate_right(R_2), v1_new);
 
-                // 4x (m4, R3, R4)
-                let v0 = v0_new;
-                let v1 = v1_new;
-                let v2 = v2_new;
-                let v3 = v3_new;
+                v0_outer[i] = v0_new;
+                v1_outer[i] = v1_new;
+                v2_outer[i] = v2_new;
+                v3_outer[i] = v3_new;
+            }
+
+            // 4x (m4, R3, R4)
+            for i in 0..4usize {
+                let v0 = v0_outer[i];
+                let v1 = v1_outer[i];
+                let v2 = v2_outer[i];
+                let v3 = v3_outer[i];
+                let m4 = event.b_reads[i + 12].value;
+                let zero1 = event.b_reads[i + 16].value;
+                let zero2 = event.b_reads[i + 20].value;
+                assert_eq!(zero1, 0);
+                assert_eq!(zero2, 0);
 
                 // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
                 let v0_new =
@@ -491,46 +553,70 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
                 assert_eq!(v0 + v1 + m4 + zero1, v0_new);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
-                cols.unshuffled_indices[i + 12] = F::from_canonical_u32(1);
-                let temp = cols.xor[i + 16 + 8].populate(output, shard, event.channel, v3, v0);
-                let v3_new = cols.rotate_right[v3_unshuffle_lookup[i] + 16 + 8].populate(
-                    //let v3_new = cols.rotate_right[i + 16 + 8].populate(
+                //cols.unshuffled_indices[i + 12] = F::from_canonical_u32(1);
+                let temp = cols.xor[i + 16 + 8].populate(output, shard, event.channel, v3, v0_new);
+                //let v3_new = cols.rotate_right[v3_unshuffle_lookup[i] + 16 + 8].populate(
+                let v3_new = cols.rotate_right[i + 16 + 8].populate(
                     output,
                     shard,
                     event.channel,
                     temp,
                     R_3 as usize,
                 );
-                assert_eq!((v3 ^ v0).rotate_right(R_3), v3_new);
+                assert_eq!((v3 ^ v0_new).rotate_right(R_3), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                cols.unshuffled_indices[i + 8] = F::from_canonical_u32(1);
-                let v2_new = cols.add[v2_unshuffle_lookup[i] + 16 + 4 + 8].populate(
-                    //let v2_new = cols.add[i + 16 + 4 + 8].populate(
+                //cols.unshuffled_indices[i + 8] = F::from_canonical_u32(1);
+                //let v2_new = cols.add[v2_unshuffle_lookup[i] + 16 + 4 + 8].populate(
+                let v2_new = cols.add[i + 16 + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
                     v2,
-                    v3,
+                    v3_new,
                     zero1,
                     zero2,
                 );
-                assert_eq!(v2 + v3 + zero1 + zero2, v2_new);
+                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
-                cols.unshuffled_indices[i + 4] = F::from_canonical_u32(1);
-                let temp = cols.xor[i + 16 + 4 + 8].populate(output, shard, event.channel, v1, v2);
-                let v1_new = cols.rotate_right[v1_unshuffle_lookup[i] + 16 + 4 + 8].populate(
-                    //let v1_new = cols.rotate_right[i + 16 + 4 + 8].populate(
+                //cols.unshuffled_indices[i + 4] = F::from_canonical_u32(1);
+                let temp =
+                    cols.xor[i + 16 + 4 + 8].populate(output, shard, event.channel, v1, v2_new);
+                //let v1_new = cols.rotate_right[v1_unshuffle_lookup[i] + 16 + 4 + 8].populate(
+                let v1_new = cols.rotate_right[i + 16 + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
                     temp,
                     R_4 as usize,
                 );
-                assert_eq!((v1 ^ v2).rotate_right(R_4), v1_new);
+                assert_eq!((v1 ^ v2_new).rotate_right(R_4), v1_new);
+
+                //v0_outer[i] = v0_new;
+                //v1_outer[i] = v1_new;
+                //v2_outer[i] = v2_new;
+                //v3_outer[i] = v3_new;
             }
 
+            /*
+            // unshuffle
+            // v[1]
+            v1_outer.swap(2, 3);
+            v1_outer.swap(1, 2);
+            v1_outer.swap(0, 1);
+
+            // v[2]
+            v2_outer.swap(0, 2);
+            v2_outer.swap(1, 3);
+
+            // v[3]
+            v3_outer.swap(0, 3);
+            v3_outer.swap(0, 1);
+            v3_outer.swap(1, 2);*/
+
+            //println!("4x traces: {:02x?}", [v0_outer, v1_outer, v2_outer, v3_outer].concat().to_vec());
+
             rows.push(row);
         }
 
@@ -547,7 +633,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
 
         // Write the nonces to the trace.
         for i in 0..trace.height() {
-            let cols: &mut Blake2sQuarterRound2xCols<F> =
+            let cols: &mut Blake2sRoundCols<F> =
                 trace.values[i * width..(i + 1) * width].borrow_mut();
             cols.nonce = F::from_canonical_usize(i);
         }
@@ -556,11 +642,11 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sQuarterRound2xChip {
     }
 
     fn included(&self, shard: &Self::Record) -> bool {
-        !shard.blake2s_quarter_round_2x_events.is_empty()
+        !shard.blake2s_round_events.is_empty()
     }
 }
 
-impl<AB: SphinxAirBuilder> Air<AB> for Blake2sQuarterRound2xChip
+impl<AB: SphinxAirBuilder> Air<AB> for Blake2sRoundChip
 where
     AB::F: PrimeField32,
 {
@@ -568,8 +654,8 @@ where
         let main = builder.main();
         let local = main.row_slice(0);
         let next = main.row_slice(1);
-        let local: &Blake2sQuarterRound2xCols<AB::Var> = (*local).borrow();
-        let next: &Blake2sQuarterRound2xCols<AB::Var> = (*next).borrow();
+        let local: &Blake2sRoundCols<AB::Var> = (*local).borrow();
+        let next: &Blake2sRoundCols<AB::Var> = (*next).borrow();
 
         // Constrain the incrementing nonce.
         builder.when_first_row().assert_zero(local.nonce);
@@ -616,20 +702,16 @@ where
         let v2_shuffle_lookup = vec![2, 3, 0, 1];
         let v3_shuffle_lookup = vec![3, 0, 1, 2];
 
-        let v1_unshuffle_lookup = v1_shuffle_lookup.clone();
-        let v2_unshuffle_lookup = v2_shuffle_lookup.clone();
-        let v3_unshuffle_lookup = v3_shuffle_lookup.clone();
-
         for i in 0..4usize {
             // 1x
 
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
                 builder,
-                *local.a[i].value(),     // v0
-                *local.a[i + 4].value(), // v1
-                *local.b[i].value(),     // m1
-                *local.b[i + 8].value(), // zero1
+                *local.a[i].prev_value(),     // v0
+                *local.a[i + 4].prev_value(), // v1
+                *local.b[i].value(),          // m1
+                *local.b[i + 20].value(),     // zero1
                 local.shard,
                 local.channel,
                 local.is_real,
@@ -640,13 +722,14 @@ where
             // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
-                *local.a[i + 12].value(),
-                *local.a[i].value(),
+                *local.a[i + 12].prev_value(),
+                local.add[i].value,
                 local.xor[i],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
+
             // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
@@ -661,10 +744,10 @@ where
             // v[2] = v[2].wrapping_add(v[3]);
             Add4Operation::<AB::F>::eval(
                 builder,
-                *local.a[i + 8].value(),  // v2
-                *local.a[i + 12].value(), // v3
-                *local.b[i + 8].value(),  // zero1
-                *local.b[i + 12].value(), // zero2
+                *local.a[i + 8].prev_value(), // v2
+                local.rotate_right[i].value,  // v3 from previous operation
+                *local.b[i + 16].value(),     // zero1
+                *local.b[i + 20].value(),     // zero2
                 local.shard,
                 local.channel,
                 local.is_real,
@@ -675,8 +758,8 @@ where
             // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
-                *local.a[i + 4].value(),
-                *local.a[i + 8].value(),
+                *local.a[i + 4].prev_value(),
+                local.add[i + 4].value,
                 local.xor[i + 4],
                 local.shard,
                 &local.channel,
@@ -695,14 +778,13 @@ where
             );
 
             // 2x
-
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
                 builder,
                 local.add[i].value,              // v0 after 1x
                 local.rotate_right[i + 4].value, // v1 after 1x
                 *local.b[i + 4].value(),         // m2
-                *local.b[i + 8].value(),         // zero1
+                *local.b[i + 16].value(),        // zero1
                 local.shard,
                 local.channel,
                 local.is_real,
@@ -714,7 +796,7 @@ where
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i].value, // v3 after 1x
-                local.add[i].value,          // v0 after 1x
+                local.add[i + 8].value,      // v0 after 1x
                 local.xor[i + 8],
                 local.shard,
                 &local.channel,
@@ -726,7 +808,7 @@ where
                 builder,
                 local.xor[i + 8].value,
                 R_3 as usize,
-                local.rotate_right[v3_shuffle_lookup[i] + 8],
+                local.rotate_right[i + 8],
                 local.shard,
                 &local.channel,
                 local.is_real,
@@ -735,14 +817,14 @@ where
             // v[2] = v[2].wrapping_add(v[3]);
             Add4Operation::<AB::F>::eval(
                 builder,
-                local.add[i + 4].value,      // v2 after 1x
-                local.rotate_right[i].value, // v3 after 1x
-                *local.b[i + 8].value(),     // zero1
-                *local.b[i + 12].value(),    // zero2
+                local.add[i + 4].value,          // v2 after 1x
+                local.rotate_right[i + 8].value, // v3 after previous operation
+                *local.b[i + 16].value(),        // zero1
+                *local.b[i + 20].value(),        // zero2
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[v2_shuffle_lookup[i] + 12],
+                local.add[i + 12],
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
@@ -750,7 +832,7 @@ where
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i + 4].value, // v1 after 1x
-                local.add[i + 4].value,          // v2 after 1x
+                local.add[i + 12].value,         // v2 after previous operation
                 local.xor[i + 12],
                 local.shard,
                 &local.channel,
@@ -762,21 +844,21 @@ where
                 builder,
                 local.xor[i + 12].value,
                 R_4 as usize,
-                local.rotate_right[v1_shuffle_lookup[i] + 12],
+                local.rotate_right[i + 12],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
         }
 
-        self.constrain_shuffled_unshuffled_indices(builder, &local.shuffled_indices, local.is_real);
+        self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
 
         for i in 0..4usize {
             // 3x
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
                 builder,
-                local.add[i + 8].value, // v0 after x2
+                local.add[i + 8].value, // v0 after 2x
                 local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
                 *local.b[i + 8].value(), // m3
                 *local.b[i + 16].value(), // zero1
@@ -791,7 +873,7 @@ where
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x
-                local.add[i + 8].value,                             // v0 after x2
+                local.add[i + 16].value,                            // v0 after previous operation
                 local.xor[i + 16],
                 local.shard,
                 &local.channel,
@@ -813,7 +895,7 @@ where
             Add4Operation::<AB::F>::eval(
                 builder,
                 local.add[v2_shuffle_lookup[i] + 12].value, // v2 after 2x
-                local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x
+                local.rotate_right[i + 16].value,           // v3 after previous operation
                 *local.b[i + 16].value(),                   // zero1
                 *local.b[i + 20].value(),                   // zero2
                 local.shard,
@@ -827,7 +909,7 @@ where
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
-                local.add[v2_shuffle_lookup[i] + 12].value,          // v2 after 2x
+                local.add[i + 20].value,                             // v2 after previous operation
                 local.xor[i + 20],
                 local.shard,
                 &local.channel,
@@ -864,7 +946,7 @@ where
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i + 16].value, // v3 after 3x
-                local.add[i + 16].value,          // v0 after 3x
+                local.add[i + 24].value,          // v0 after previous operation
                 local.xor[i + 24],
                 local.shard,
                 &local.channel,
@@ -876,7 +958,7 @@ where
                 builder,
                 local.xor[i + 24].value,
                 R_3 as usize,
-                local.rotate_right[v3_unshuffle_lookup[i] + 24],
+                local.rotate_right[i + 24],
                 local.shard,
                 &local.channel,
                 local.is_real,
@@ -886,13 +968,13 @@ where
             Add4Operation::<AB::F>::eval(
                 builder,
                 local.add[i + 20].value,          // v2 after 3x
-                local.rotate_right[i + 16].value, // v3 after 3x
+                local.rotate_right[i + 24].value, // v3 after previous operation
                 *local.b[i + 16].value(),         // zero1
                 *local.b[i + 20].value(),         // zero2
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[v2_unshuffle_lookup[i] + 28],
+                local.add[i + 28],
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
@@ -900,7 +982,7 @@ where
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i + 20].value, // v1 after 3x
-                local.add[i + 20].value,          // v2 after 3x
+                local.add[i + 28].value,          // v2 after previous operation
                 local.xor[i + 28],
                 local.shard,
                 &local.channel,
@@ -912,25 +994,25 @@ where
                 builder,
                 local.xor[i + 28].value,
                 R_4 as usize,
-                local.rotate_right[v1_unshuffle_lookup[i] + 28],
+                local.rotate_right[i + 28],
                 local.shard,
                 &local.channel,
                 local.is_real,
             );
         }
 
-        self.constrain_shuffled_unshuffled_indices(
+        /*self.constrain_shuffled_unshuffled_indices(
             builder,
             &local.unshuffled_indices,
             local.is_real,
-        );
+        );*/
 
         builder.receive_syscall(
             local.shard,
             local.channel,
             local.clk,
             local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_QUARTER_ROUND_2X.syscall_id()),
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_ROUND.syscall_id()),
             local.a_ptr,
             local.b_ptr,
             local.is_real,
@@ -941,9 +1023,11 @@ where
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Instruction, Opcode, SyscallCode};
+    use crate::syscall::precompiles::blake2s::blake2s_round;
     use crate::utils::tests::BLAKE2S_ROUND_ELF;
     use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
     use crate::Program;
+    use rand::Rng;
 
     fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 16], b: [u32; 24]) -> Program {
         let mut instructions = vec![];
@@ -980,7 +1064,7 @@ mod tests {
             Opcode::ADD,
             5,
             0,
-            SyscallCode::BLAKE_2S_QUARTER_ROUND_2X as u32,
+            SyscallCode::BLAKE_2S_ROUND as u32,
             false,
             true,
         ));
@@ -996,23 +1080,17 @@ mod tests {
 
         let a_ptr = 100100100;
         let b_ptr = 200200200;
-        let program = risc_v_program(
-            a_ptr,
-            b_ptr,
-            [
-                0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
-                0x5be0cd19, 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
-                0xe07c2654, 0x5be0cd19,
-            ],
-            [
-                0, 0, 0, 0, // m1
-                0, 0, 0, 0, // m2
-                0, 0, 0, 0, // m3
-                0, 0, 0, 0, // m4
-                0, 0, 0, 0, // zero_0
-                0, 0, 0, 0,
-            ], // zero_1
-        );
+
+        let a = rand::thread_rng().gen::<[u32; 16]>();
+        let mut a_clone = a.clone();
+        let mut b = rand::thread_rng().gen::<[u32; 24]>();
+        for item in b[0..24].iter_mut() {
+            *item = 0;
+        }
+
+        blake2s_round(&mut a_clone, &b);
+
+        let program = risc_v_program(a_ptr, b_ptr, a, b);
 
         let (_, memory) = run_test_with_memory_inspection(program);
         let mut result = vec![];
@@ -1021,15 +1099,7 @@ mod tests {
             result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
         }
 
-        assert_eq!(
-            result,
-            [
-                0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3, 0x515f5af4, 0x301095b, 0xb151a3c2,
-                0x5e17f96f, 0xc561666d, 0xf291605, 0x990c6d13, 0x76fff6f1, 0x1e53bf19, 0x6fe4a680,
-                0x8e33663, 0x97fd885e,
-            ]
-            .to_vec()
-        );
+        assert_eq!(result, a_clone.to_vec());
     }
 
     #[test]
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/air.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/air.rs
deleted file mode 100644
index 3ddd0f4f7..000000000
--- a/core/src/syscall/precompiles/blake2s/xor_rotate_16/air.rs
+++ /dev/null
@@ -1,291 +0,0 @@
-use core::borrow::Borrow;
-
-use p3_air::{Air, AirBuilder, BaseAir};
-use p3_field::AbstractField;
-use p3_matrix::Matrix;
-
-use super::{Blake2sXorRotate16Chip, Blake2sXorRotate16Cols, NUM_BLAKE2S_XOR_ROTATE_16_COLS};
-use crate::{
-    air::{AluAirBuilder, BaseAirBuilder, MemoryAirBuilder, WordAirBuilder},
-    memory::MemoryCols,
-    operations::{FixedRotateRightOperation, XorOperation},
-    runtime::SyscallCode,
-};
-
-impl<F> BaseAir<F> for Blake2sXorRotate16Chip {
-    fn width(&self) -> usize {
-        NUM_BLAKE2S_XOR_ROTATE_16_COLS
-    }
-}
-
-impl<AB> Air<AB> for Blake2sXorRotate16Chip
-where
-    AB: MemoryAirBuilder + AluAirBuilder + WordAirBuilder,
-{
-    fn eval(&self, builder: &mut AB) {
-        // Initialize columns.
-        let main = builder.main();
-        let (local, next) = (main.row_slice(0), main.row_slice(1));
-        let local: &Blake2sXorRotate16Cols<AB::Var> = (*local).borrow();
-        let next: &Blake2sXorRotate16Cols<AB::Var> = (*next).borrow();
-
-        // Constrain the incrementing nonce.
-        builder.when_first_row().assert_zero(local.nonce);
-        builder
-            .when_transition()
-            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
-
-        let i_start = AB::F::from_canonical_u32(16);
-
-        // Evaluate the control flags.
-        self.eval_flags(builder);
-
-        // Copy over the inputs until the result has been computed (every 48 rows).
-        builder
-            .when_transition()
-            .when_not(local.cycle_16_end.result * local.cycle_48[2])
-            .assert_eq(local.shard, next.shard);
-        builder
-            .when_transition()
-            .when_not(local.cycle_16_end.result * local.cycle_48[2])
-            .assert_eq(local.clk, next.clk);
-        builder
-            .when_transition()
-            .when_not(local.cycle_16_end.result * local.cycle_48[2])
-            .assert_eq(local.channel, next.channel);
-        builder
-            .when_transition()
-            .when_not(local.cycle_16_end.result * local.cycle_48[2])
-            .assert_eq(local.w_ptr, next.w_ptr);
-
-        // Read w[0].
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(0),
-            &local.w_0,
-            local.is_real,
-        );
-
-        // Read w[1]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(4),
-            &local.w_1,
-            local.is_real,
-        );
-
-        // Read w[2]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(8),
-            &local.w_2,
-            local.is_real,
-        );
-
-        // Read w[3]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(12),
-            &local.w_3,
-            local.is_real,
-        );
-
-        // Read w[4]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(16),
-            &local.w_4,
-            local.is_real,
-        );
-
-        // Read w[5]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(20),
-            &local.w_5,
-            local.is_real,
-        );
-
-        // Read w[6]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(24),
-            &local.w_6,
-            local.is_real,
-        );
-
-        // Read w[7]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(28),
-            &local.w_7,
-            local.is_real,
-        );
-
-        XorOperation::<AB::F>::eval(
-            builder,
-            *local.w_0.value(),
-            *local.w_4.value(),
-            local.xor_0,
-            local.shard,
-            &local.channel,
-            local.is_real,
-        );
-
-        FixedRotateRightOperation::<AB::F>::eval(
-            builder,
-            local.xor_0.value,
-            16,
-            local.rot_0,
-            local.shard,
-            &local.channel,
-            local.is_real,
-        );
-
-        XorOperation::<AB::F>::eval(
-            builder,
-            *local.w_1.value(),
-            *local.w_5.value(),
-            local.xor_1,
-            local.shard,
-            &local.channel,
-            local.is_real,
-        );
-
-        FixedRotateRightOperation::<AB::F>::eval(
-            builder,
-            local.xor_1.value,
-            16,
-            local.rot_1,
-            local.shard,
-            &local.channel,
-            local.is_real,
-        );
-
-        XorOperation::<AB::F>::eval(
-            builder,
-            *local.w_2.value(),
-            *local.w_6.value(),
-            local.xor_2,
-            local.shard,
-            &local.channel,
-            local.is_real,
-        );
-
-        FixedRotateRightOperation::<AB::F>::eval(
-            builder,
-            local.xor_2.value,
-            16,
-            local.rot_2,
-            local.shard,
-            &local.channel,
-            local.is_real,
-        );
-
-        XorOperation::<AB::F>::eval(
-            builder,
-            *local.w_3.value(),
-            *local.w_7.value(),
-            local.xor_3,
-            local.shard,
-            &local.channel,
-            local.is_real,
-        );
-
-        FixedRotateRightOperation::<AB::F>::eval(
-            builder,
-            local.xor_3.value,
-            16,
-            local.rot_3,
-            local.shard,
-            &local.channel,
-            local.is_real,
-        );
-
-        // Write w[16]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(64),
-            &local.w_16,
-            local.is_real,
-        );
-
-        // Write w[17]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(68),
-            &local.w_17,
-            local.is_real,
-        );
-
-        // Write w[18]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(72),
-            &local.w_18,
-            local.is_real,
-        );
-
-        // Write w[19]
-        builder.eval_memory_access(
-            local.shard,
-            local.channel,
-            local.clk + (local.i - i_start),
-            local.w_ptr + AB::F::from_canonical_u32(76),
-            &local.w_19,
-            local.is_real,
-        );
-
-        builder.assert_word_eq(*local.w_16.value(), local.rot_0.value);
-        builder.assert_word_eq(*local.w_17.value(), local.rot_1.value);
-        builder.assert_word_eq(*local.w_18.value(), local.rot_2.value);
-        builder.assert_word_eq(*local.w_19.value(), local.rot_3.value);
-
-        // Receive syscall event in first row of 48-cycle.
-        builder.receive_syscall(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_16.syscall_id()),
-            local.w_ptr,
-            AB::Expr::zero(),
-            local.cycle_48_start,
-        );
-
-        // Assert that is_real is a bool.
-        builder.assert_bool(local.is_real);
-
-        // Ensure that all rows in a 48 row cycle has the same `is_real` values.
-        builder
-            .when_transition()
-            .when_not(local.cycle_48_end)
-            .assert_eq(local.is_real, next.is_real);
-
-        // Assert that the table ends in nonreal columns. Since each extend ecall is 48 cycles and
-        // the table is padded to a power of 2, the last row of the table should always be padding.
-        builder.when_last_row().assert_zero(local.is_real);
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/columns.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/columns.rs
deleted file mode 100644
index 06fc34153..000000000
--- a/core/src/syscall/precompiles/blake2s/xor_rotate_16/columns.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use std::mem::size_of;
-
-use sphinx_derive::AlignedBorrow;
-
-use crate::{
-    memory::{MemoryReadCols, MemoryWriteCols},
-    operations::{FixedRotateRightOperation, IsZeroOperation, XorOperation},
-};
-
-pub const NUM_BLAKE2S_XOR_ROTATE_16_COLS: usize = size_of::<Blake2sXorRotate16Cols<u8>>();
-
-#[derive(AlignedBorrow, Default, Debug, Clone, Copy)]
-#[repr(C)]
-pub struct Blake2sXorRotate16Cols<T> {
-    /// Inputs.
-    pub shard: T,
-    pub channel: T,
-    pub nonce: T,
-    pub clk: T,
-    pub w_ptr: T,
-
-    /// Control flags.
-    pub i: T,
-
-    /// g^n where g is generator with order 16 and n is the row number.
-    pub cycle_16: T,
-
-    /// Checks whether current row is start of a 16-row cycle. Bool result is stored in `result`.
-    pub cycle_16_start: IsZeroOperation<T>,
-
-    /// Checks whether current row is end of a 16-row cycle. Bool result is stored in `result`.
-    pub cycle_16_end: IsZeroOperation<T>,
-
-    /// Flags for when in the first, second, or third 16-row cycle.
-    pub cycle_48: [T; 3],
-
-    /// Whether the current row is the first of a 48-row cycle and is real.
-    pub cycle_48_start: T,
-    /// Whether the current row is the end of a 48-row cycle and is real.
-    pub cycle_48_end: T,
-
-    /// Inputs
-    pub w_0: MemoryReadCols<T>,
-    pub w_1: MemoryReadCols<T>,
-    pub w_2: MemoryReadCols<T>,
-    pub w_3: MemoryReadCols<T>,
-    pub w_4: MemoryReadCols<T>,
-    pub w_5: MemoryReadCols<T>,
-    pub w_6: MemoryReadCols<T>,
-    pub w_7: MemoryReadCols<T>,
-
-    /// Operations
-    pub xor_0: XorOperation<T>,
-    pub xor_1: XorOperation<T>,
-    pub xor_2: XorOperation<T>,
-    pub xor_3: XorOperation<T>,
-
-    pub rot_0: FixedRotateRightOperation<T>,
-    pub rot_1: FixedRotateRightOperation<T>,
-    pub rot_2: FixedRotateRightOperation<T>,
-    pub rot_3: FixedRotateRightOperation<T>,
-
-    /// Result
-    pub w_16: MemoryWriteCols<T>,
-    pub w_17: MemoryWriteCols<T>,
-    pub w_18: MemoryWriteCols<T>,
-    pub w_19: MemoryWriteCols<T>,
-
-    /// Selector.
-    pub is_real: T,
-}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/execute.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/execute.rs
deleted file mode 100644
index 8a890b9e6..000000000
--- a/core/src/syscall/precompiles/blake2s/xor_rotate_16/execute.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use super::Blake2sXorRotate16Chip;
-use crate::{
-    runtime::Syscall,
-    syscall::precompiles::{blake2s::Blake2sXorRotate16Event, SyscallContext},
-};
-
-impl Syscall for Blake2sXorRotate16Chip {
-    fn num_extra_cycles(&self) -> u32 {
-        48
-    }
-
-    fn execute(&self, rt: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
-        let clk_init = rt.clk;
-        let w_ptr = arg1;
-        assert!(arg2 == 0, "arg2 must be 0");
-
-        let w_ptr_init = w_ptr;
-        let mut w_0_reads = Vec::new();
-        let mut w_1_reads = Vec::new();
-        let mut w_2_reads = Vec::new();
-        let mut w_3_reads = Vec::new();
-
-        let mut w_4_reads = Vec::new();
-        let mut w_5_reads = Vec::new();
-        let mut w_6_reads = Vec::new();
-        let mut w_7_reads = Vec::new();
-
-        let mut w_16_writes = Vec::new();
-        let mut w_17_writes = Vec::new();
-        let mut w_18_writes = Vec::new();
-        let mut w_19_writes = Vec::new();
-
-        for _ in 16..64 {
-            // read
-            let (record, w_0) = rt.mr(w_ptr);
-            w_0_reads.push(record);
-
-            let (record, w_1) = rt.mr(w_ptr + 4);
-            w_1_reads.push(record);
-
-            let (record, w_2) = rt.mr(w_ptr + 8);
-            w_2_reads.push(record);
-
-            let (record, w_3) = rt.mr(w_ptr + 12);
-            w_3_reads.push(record);
-
-            let (record, w_4) = rt.mr(w_ptr + 16);
-            w_4_reads.push(record);
-
-            let (record, w_5) = rt.mr(w_ptr + 20);
-            w_5_reads.push(record);
-
-            let (record, w_6) = rt.mr(w_ptr + 24);
-            w_6_reads.push(record);
-
-            let (record, w_7) = rt.mr(w_ptr + 28);
-            w_7_reads.push(record);
-
-            // compute
-            let w_16 = (w_0 ^ w_4).rotate_right(16);
-            let w_17 = (w_1 ^ w_5).rotate_right(16);
-            let w_18 = (w_2 ^ w_6).rotate_right(16);
-            let w_19 = (w_3 ^ w_7).rotate_right(16);
-
-            // write
-            w_16_writes.push(rt.mw(w_ptr + 64, w_16));
-            w_17_writes.push(rt.mw(w_ptr + 68, w_17));
-            w_18_writes.push(rt.mw(w_ptr + 72, w_18));
-            w_19_writes.push(rt.mw(w_ptr + 76, w_19));
-            rt.clk += 1;
-        }
-
-        // Push the Blake2sXorRotate16Event event.
-        let lookup_id = rt.syscall_lookup_id;
-        let shard = rt.current_shard();
-        let channel = rt.current_channel();
-        rt.record_mut()
-            .blake2s_xor_rotate_16_events
-            .push(Blake2sXorRotate16Event {
-                lookup_id,
-                shard,
-                channel,
-                clk: clk_init,
-                w_ptr: w_ptr_init,
-                w_0_reads,
-                w_1_reads,
-                w_2_reads,
-                w_3_reads,
-                w_4_reads,
-                w_5_reads,
-                w_6_reads,
-                w_7_reads,
-                w_16_writes,
-                w_17_writes,
-                w_18_writes,
-                w_19_writes,
-            });
-
-        None
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/flags.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/flags.rs
deleted file mode 100644
index 2f705b9f2..000000000
--- a/core/src/syscall/precompiles/blake2s/xor_rotate_16/flags.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-use core::borrow::Borrow;
-
-use p3_air::AirBuilder;
-use p3_baby_bear::BabyBear;
-use p3_field::{AbstractField, Field, PrimeField32, TwoAdicField};
-use p3_matrix::Matrix;
-
-use crate::air::BaseAirBuilder;
-use crate::operations::IsZeroOperation;
-
-use super::Blake2sXorRotate16Chip;
-use super::Blake2sXorRotate16Cols;
-
-impl<F: Field> Blake2sXorRotate16Cols<F> {
-    pub fn populate_flags(&mut self, i: usize) {
-        // The generator of the multiplicative subgroup.
-        let g = F::from_canonical_u32(BabyBear::two_adic_generator(4).as_canonical_u32());
-
-        // Populate the columns needed to keep track of cycles of 16 rows.
-        self.cycle_16 = g.exp_u64((i + 1) as u64);
-
-        // Populate the columns needed to track the start of a cycle of 16 rows.
-        self.cycle_16_start
-            .populate_from_field_element(self.cycle_16 - g);
-
-        // Populate the columns needed to track the end of a cycle of 16 rows.
-        self.cycle_16_end
-            .populate_from_field_element(self.cycle_16 - F::one());
-
-        // Populate the columns needed to keep track of cycles of 48 rows.
-        let j = 16 + (i % 48);
-        self.i = F::from_canonical_usize(j);
-        self.cycle_48[0] = F::from_bool((16..32).contains(&j));
-        self.cycle_48[1] = F::from_bool((32..48).contains(&j));
-        self.cycle_48[2] = F::from_bool((48..64).contains(&j));
-        self.cycle_48_start = self.cycle_48[0] * self.cycle_16_start.result * self.is_real;
-        self.cycle_48_end = self.cycle_48[2] * self.cycle_16_end.result * self.is_real;
-    }
-}
-
-impl Blake2sXorRotate16Chip {
-    pub fn eval_flags<AB: BaseAirBuilder>(&self, builder: &mut AB) {
-        let main = builder.main();
-        let (local, next) = (main.row_slice(0), main.row_slice(1));
-        let local: &Blake2sXorRotate16Cols<AB::Var> = (*local).borrow();
-        let next: &Blake2sXorRotate16Cols<AB::Var> = (*next).borrow();
-
-        let one = AB::Expr::from(AB::F::one());
-
-        // Generator with order 16 within BabyBear.
-        let g = AB::F::from_canonical_u32(BabyBear::two_adic_generator(4).as_canonical_u32());
-
-        // First row of the table must have g^1.
-        builder.when_first_row().assert_eq(local.cycle_16, g);
-
-        // First row of the table must have i = 16.
-        builder
-            .when_first_row()
-            .assert_eq(local.i, AB::F::from_canonical_u32(16));
-
-        // Every row's `cycle_16` must be previous multiplied by `g`.
-        builder
-            .when_transition()
-            .assert_eq(local.cycle_16 * g, next.cycle_16);
-
-        // Constrain `cycle_16_start.result` to be `cycle_16 - g == 0`.
-        IsZeroOperation::<AB::F>::eval(
-            builder,
-            local.cycle_16 - AB::Expr::from(g),
-            local.cycle_16_start,
-            one.clone(),
-        );
-
-        // Constrain `cycle_16_end.result` to be `cycle_16 - 1 == 0`. Intuitively g^16 is 1.
-        IsZeroOperation::<AB::F>::eval(
-            builder,
-            local.cycle_16 - AB::Expr::one(),
-            local.cycle_16_end,
-            one.clone(),
-        );
-
-        // Constrain `cycle_48` to be [1, 0, 0] in the first row.
-        builder
-            .when_first_row()
-            .assert_eq(local.cycle_48[0], AB::F::one());
-        builder
-            .when_first_row()
-            .assert_eq(local.cycle_48[1], AB::F::zero());
-        builder
-            .when_first_row()
-            .assert_eq(local.cycle_48[2], AB::F::zero());
-
-        // Shift the indices of `cycles_48` at the end of each 16 rows. Otherwise, keep them the same.
-        for i in 0..3 {
-            builder
-                .when_transition()
-                .when(local.cycle_16_end.result)
-                .assert_eq(local.cycle_48[i], next.cycle_48[(i + 1) % 3]);
-            builder
-                .when_transition()
-                .when(one.clone() - local.cycle_16_end.result)
-                .assert_eq(local.cycle_48[i], next.cycle_48[i]);
-            builder.assert_bool(local.cycle_48[i]);
-        }
-
-        // cycle_48_start == start of 16-cycle AND first 16-cycle within 48-cycle AND is_real.
-        builder.assert_eq(
-            local.cycle_16_start.result * local.cycle_48[0] * local.is_real,
-            local.cycle_48_start,
-        );
-
-        // cycle_48_end == end of 16-cycle AND last 16-cycle within 48-cycle AND is_real.
-        builder.assert_eq(
-            local.cycle_16_end.result * local.cycle_48[2] * local.is_real,
-            local.cycle_48_end,
-        );
-
-        // When it's the end of a 48-cycle, the next `i` must be 16.
-        builder
-            .when_transition()
-            .when(local.cycle_16_end.result * local.cycle_48[2])
-            .assert_eq(next.i, AB::F::from_canonical_u32(16));
-
-        // When it's not the end of a 48-cycle, the next `i` must be the current plus one.
-        builder
-            .when_transition()
-            .when_not(local.cycle_16_end.result * local.cycle_48[2])
-            .assert_eq(local.i + one.clone(), next.i);
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/mod.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/mod.rs
deleted file mode 100644
index 913777829..000000000
--- a/core/src/syscall/precompiles/blake2s/xor_rotate_16/mod.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-mod air;
-mod columns;
-mod execute;
-mod flags;
-mod trace;
-
-pub use columns::*;
-use serde::{Deserialize, Serialize};
-
-use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Blake2sXorRotate16Event {
-    pub lookup_id: usize,
-    pub shard: u32,
-    pub channel: u32,
-    pub clk: u32,
-    pub w_ptr: u32,
-
-    pub w_0_reads: Vec<MemoryReadRecord>,
-    pub w_1_reads: Vec<MemoryReadRecord>,
-    pub w_2_reads: Vec<MemoryReadRecord>,
-    pub w_3_reads: Vec<MemoryReadRecord>,
-    pub w_4_reads: Vec<MemoryReadRecord>,
-    pub w_5_reads: Vec<MemoryReadRecord>,
-    pub w_6_reads: Vec<MemoryReadRecord>,
-    pub w_7_reads: Vec<MemoryReadRecord>,
-
-    pub w_16_writes: Vec<MemoryWriteRecord>,
-    pub w_17_writes: Vec<MemoryWriteRecord>,
-    pub w_18_writes: Vec<MemoryWriteRecord>,
-    pub w_19_writes: Vec<MemoryWriteRecord>,
-}
-
-#[derive(Default)]
-pub struct Blake2sXorRotate16Chip;
-
-impl Blake2sXorRotate16Chip {
-    pub const fn new() -> Self {
-        Self {}
-    }
-}
-
-#[cfg(test)]
-pub mod blake2s_xor_rotate_tests {
-    use crate::utils::run_test;
-    use crate::utils::tests::BLAKE2S_XOR_RIGHT_16_ELF;
-    use crate::{
-        runtime::{Instruction, Opcode, Program, SyscallCode},
-        utils::{self, run_test_with_memory_inspection},
-    };
-
-    pub fn blake2s_xor_rotate_16_program() -> Program {
-        let w_ptr = 100u32;
-        let mut words = [0u32; 64];
-        words[0] = 0x6b08e647;
-        words[1] = 0xbb67ae85;
-        words[2] = 0x3c6ef372;
-        words[3] = 0xa54ff53a;
-
-        words[4] = 0x510e527f;
-        words[5] = 0x9b05688c;
-        words[6] = 0x1f83d9ab;
-        words[7] = 0x5be0cd19;
-
-        let mut instructions = vec![];
-        for (i, word) in words.into_iter().enumerate() {
-            instructions.extend(vec![
-                Instruction::new(Opcode::ADD, 29, 0, word, false, true),
-                Instruction::new(Opcode::ADD, 30, 0, w_ptr + (i * 4) as u32, false, true),
-                Instruction::new(Opcode::SW, 29, 30, 0, false, true),
-            ]);
-        }
-        instructions.extend(vec![
-            Instruction::new(
-                Opcode::ADD,
-                5,
-                0,
-                SyscallCode::BLAKE_2S_XOR_ROTATE_16 as u32,
-                false,
-                true,
-            ),
-            Instruction::new(Opcode::ADD, 10, 0, w_ptr, false, true),
-            Instruction::new(Opcode::ADD, 11, 0, 0, false, true),
-            Instruction::new(Opcode::ECALL, 5, 10, 11, false, false),
-        ]);
-        Program::new(instructions, 0, 0)
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_16_prove() {
-        utils::setup_logger();
-        let program = blake2s_xor_rotate_16_program();
-        let (_, memory) = run_test_with_memory_inspection(program);
-        let mut result = vec![];
-        for i in 0..64 {
-            result.push(memory.get(&(100 + i * 4)).unwrap().value);
-        }
-        assert_eq!(
-            result,
-            vec![
-                0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
-                0x5be0cd19, 0, 0, 0, 0, 0, 0, 0, 0, 0xb4383a06, 0xc6092062, 0x2ad923ed, 0x3823feaf,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-            ]
-        );
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_16_program() {
-        utils::setup_logger();
-        let program = Program::from(BLAKE2S_XOR_RIGHT_16_ELF);
-        run_test(program).unwrap();
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_16/trace.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_16/trace.rs
deleted file mode 100644
index a69762463..000000000
--- a/core/src/syscall/precompiles/blake2s/xor_rotate_16/trace.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-use p3_field::PrimeField32;
-use p3_matrix::dense::RowMajorMatrix;
-use p3_matrix::Matrix;
-use std::borrow::BorrowMut;
-
-use super::{
-    Blake2sXorRotate16Chip, Blake2sXorRotate16Cols, Blake2sXorRotate16Event,
-    NUM_BLAKE2S_XOR_ROTATE_16_COLS,
-};
-use crate::{
-    air::{EventLens, MachineAir, WithEvents},
-    bytes::event::ByteRecord,
-    runtime::{ExecutionRecord, Program},
-};
-
-impl<'a> WithEvents<'a> for Blake2sXorRotate16Chip {
-    type Events = &'a [Blake2sXorRotate16Event];
-}
-
-impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotate16Chip {
-    type Record = ExecutionRecord;
-
-    type Program = Program;
-
-    fn name(&self) -> String {
-        "Blake2sXorRotate16".to_string()
-    }
-
-    fn generate_trace<EL: EventLens<Self>>(
-        &self,
-        input: &EL,
-        output: &mut ExecutionRecord,
-    ) -> RowMajorMatrix<F> {
-        let mut rows = Vec::new();
-
-        let mut new_byte_lookup_events = Vec::new();
-        for i in 0..input.events().len() {
-            let event = input.events()[i].clone();
-            let shard = event.shard;
-            for j in 0..48usize {
-                let mut row = [F::zero(); NUM_BLAKE2S_XOR_ROTATE_16_COLS];
-                let cols: &mut Blake2sXorRotate16Cols<F> = row.as_mut_slice().borrow_mut();
-                cols.is_real = F::one();
-                cols.populate_flags(j);
-                cols.shard = F::from_canonical_u32(event.shard);
-                cols.channel = F::from_canonical_u32(event.channel);
-                cols.clk = F::from_canonical_u32(event.clk);
-                cols.w_ptr = F::from_canonical_u32(event.w_ptr);
-
-                cols.w_0.populate(
-                    event.channel,
-                    event.w_0_reads[j],
-                    &mut new_byte_lookup_events,
-                );
-                cols.w_1.populate(
-                    event.channel,
-                    event.w_1_reads[j],
-                    &mut new_byte_lookup_events,
-                );
-                cols.w_2.populate(
-                    event.channel,
-                    event.w_2_reads[j],
-                    &mut new_byte_lookup_events,
-                );
-                cols.w_3.populate(
-                    event.channel,
-                    event.w_3_reads[j],
-                    &mut new_byte_lookup_events,
-                );
-                cols.w_4.populate(
-                    event.channel,
-                    event.w_4_reads[j],
-                    &mut new_byte_lookup_events,
-                );
-                cols.w_5.populate(
-                    event.channel,
-                    event.w_5_reads[j],
-                    &mut new_byte_lookup_events,
-                );
-                cols.w_6.populate(
-                    event.channel,
-                    event.w_6_reads[j],
-                    &mut new_byte_lookup_events,
-                );
-                cols.w_7.populate(
-                    event.channel,
-                    event.w_7_reads[j],
-                    &mut new_byte_lookup_events,
-                );
-
-                let w_0 = event.w_0_reads[j].value;
-                let w_1 = event.w_1_reads[j].value;
-                let w_2 = event.w_2_reads[j].value;
-                let w_3 = event.w_3_reads[j].value;
-                let w_4 = event.w_4_reads[j].value;
-                let w_5 = event.w_5_reads[j].value;
-                let w_6 = event.w_6_reads[j].value;
-                let w_7 = event.w_7_reads[j].value;
-
-                let xor_0 = cols.xor_0.populate(output, shard, event.channel, w_0, w_4);
-
-                cols.rot_0.populate(output, shard, event.channel, xor_0, 16);
-
-                let xor_1 = cols.xor_1.populate(output, shard, event.channel, w_1, w_5);
-
-                cols.rot_1.populate(output, shard, event.channel, xor_1, 16);
-
-                let xor_2 = cols.xor_2.populate(output, shard, event.channel, w_2, w_6);
-
-                cols.rot_2.populate(output, shard, event.channel, xor_2, 16);
-
-                let xor_3 = cols.xor_3.populate(output, shard, event.channel, w_3, w_7);
-
-                cols.rot_3.populate(output, shard, event.channel, xor_3, 16);
-
-                cols.w_16.populate(
-                    event.channel,
-                    event.w_16_writes[j],
-                    &mut new_byte_lookup_events,
-                );
-
-                cols.w_17.populate(
-                    event.channel,
-                    event.w_17_writes[j],
-                    &mut new_byte_lookup_events,
-                );
-
-                cols.w_18.populate(
-                    event.channel,
-                    event.w_18_writes[j],
-                    &mut new_byte_lookup_events,
-                );
-
-                cols.w_19.populate(
-                    event.channel,
-                    event.w_19_writes[j],
-                    &mut new_byte_lookup_events,
-                );
-
-                rows.push(row);
-            }
-        }
-
-        output.add_byte_lookup_events(new_byte_lookup_events);
-
-        let nb_rows = rows.len();
-        let mut padded_nb_rows = nb_rows.next_power_of_two();
-        if padded_nb_rows == 2 || padded_nb_rows == 1 {
-            padded_nb_rows = 4;
-        }
-        for i in nb_rows..padded_nb_rows {
-            let mut row = [F::zero(); NUM_BLAKE2S_XOR_ROTATE_16_COLS];
-            let cols: &mut Blake2sXorRotate16Cols<F> = row.as_mut_slice().borrow_mut();
-            cols.populate_flags(i);
-            rows.push(row);
-        }
-
-        // Convert the trace to a row major matrix.
-        let mut trace = RowMajorMatrix::new(
-            rows.into_iter().flatten().collect::<Vec<_>>(),
-            NUM_BLAKE2S_XOR_ROTATE_16_COLS,
-        );
-
-        // Write the nonces to the trace.
-        for i in 0..trace.height() {
-            let cols: &mut Blake2sXorRotate16Cols<F> = trace.values
-                [i * NUM_BLAKE2S_XOR_ROTATE_16_COLS..(i + 1) * NUM_BLAKE2S_XOR_ROTATE_16_COLS]
-                .borrow_mut();
-            cols.nonce = F::from_canonical_usize(i);
-        }
-
-        trace
-    }
-
-    fn included(&self, shard: &Self::Record) -> bool {
-        !shard.blake2s_xor_rotate_16_events.is_empty()
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_right_12.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_right_12.rs
deleted file mode 100644
index b0d966ba1..000000000
--- a/core/src/syscall/precompiles/blake2s/xor_rotate_right_12.rs
+++ /dev/null
@@ -1,357 +0,0 @@
-use crate::bytes::event::ByteRecord;
-use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::{FixedRotateRightOperation, XorOperation};
-use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
-use crate::stark::SphinxAirBuilder;
-use crate::utils::pad_rows;
-use crate::{
-    air::{EventLens, MachineAir, WithEvents},
-    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
-};
-use core::borrow::{Borrow, BorrowMut};
-use p3_air::{Air, AirBuilder, BaseAir};
-use p3_field::{AbstractField, PrimeField32};
-use p3_matrix::dense::RowMajorMatrix;
-use p3_matrix::Matrix;
-use serde::Deserialize;
-use serde::Serialize;
-use sphinx_derive::AlignedBorrow;
-use std::mem::size_of;
-
-const R_2: u32 = 12;
-
-#[derive(Default)]
-pub struct Blake2sXorRotateRight12Chip;
-
-impl Blake2sXorRotateRight12Chip {
-    pub fn new() -> Self {
-        Blake2sXorRotateRight12Chip
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Blake2sXorRotateRight12Event {
-    pub lookup_id: usize,
-    pub clk: u32,
-    pub shard: u32,
-    pub channel: u32,
-    pub a_ptr: u32,
-    pub b_ptr: u32,
-    pub a_reads_writes: Vec<MemoryWriteRecord>,
-    pub b_reads: Vec<MemoryReadRecord>,
-}
-
-impl Syscall for Blake2sXorRotateRight12Chip {
-    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
-        let clk_init = ctx.clk;
-        let shard = ctx.current_shard();
-        let lookup_id = ctx.syscall_lookup_id;
-        let channel = ctx.current_channel();
-
-        let a_ptr = arg1;
-        let b_ptr = arg2;
-
-        let a = ctx.slice_unsafe(a_ptr, 4);
-        let (b_reads, b) = ctx.mr_slice(b_ptr, 4);
-
-        let xor = a
-            .into_iter()
-            .zip(b.into_iter())
-            .map(|(a, b)| a ^ b)
-            .collect::<Vec<u32>>();
-
-        let rotate_right = xor
-            .into_iter()
-            .map(|xor_i| xor_i.rotate_right(R_2))
-            .collect::<Vec<u32>>();
-
-        ctx.clk += 1;
-
-        // Write rotate_right to a_ptr.
-        let a_reads_writes = ctx.mw_slice(a_ptr, rotate_right.as_slice());
-
-        ctx.record_mut()
-            .blake2s_xor_rotate_right_12_events
-            .push(Blake2sXorRotateRight12Event {
-                lookup_id,
-                clk: clk_init,
-                shard,
-                channel,
-                a_ptr,
-                b_ptr,
-                a_reads_writes,
-                b_reads,
-            });
-
-        None
-    }
-
-    fn num_extra_cycles(&self) -> u32 {
-        1
-    }
-}
-
-#[derive(Debug, Clone, AlignedBorrow)]
-#[repr(C)]
-struct Blake2sXorRotateRight12Cols<T> {
-    pub clk: T,
-    pub shard: T,
-    pub channel: T,
-    pub nonce: T,
-    pub is_real: T,
-
-    pub a_ptr: T,
-    pub b_ptr: T,
-
-    pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 4],
-
-    pub xor: [XorOperation<T>; 4],
-    pub rotate_right: [FixedRotateRightOperation<T>; 4],
-}
-
-impl<T: PrimeField32> BaseAir<T> for Blake2sXorRotateRight12Chip {
-    fn width(&self) -> usize {
-        size_of::<Blake2sXorRotateRight12Cols<u8>>()
-    }
-}
-
-impl<'a> WithEvents<'a> for Blake2sXorRotateRight12Chip {
-    type Events = &'a [Blake2sXorRotateRight12Event];
-}
-
-impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRight12Chip {
-    type Record = ExecutionRecord;
-    type Program = Program;
-
-    fn name(&self) -> String {
-        "Blake2sXorRotateRight12Chip".to_string()
-    }
-
-    fn generate_trace<EL: EventLens<Self>>(
-        &self,
-        input: &EL,
-        output: &mut Self::Record,
-    ) -> RowMajorMatrix<F> {
-        let mut rows = vec![];
-        let width = <Blake2sXorRotateRight12Chip as BaseAir<F>>::width(self);
-        let mut new_byte_lookup_events = Vec::new();
-        for event in input.events() {
-            let shard = event.shard;
-            let mut row = vec![F::zero(); width];
-            let cols: &mut Blake2sXorRotateRight12Cols<F> = row.as_mut_slice().borrow_mut();
-
-            cols.clk = F::from_canonical_u32(event.clk);
-            cols.is_real = F::one();
-            cols.shard = F::from_canonical_u32(event.shard);
-            cols.channel = F::from_canonical_u32(event.channel);
-            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
-            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
-
-            for i in 0..4usize {
-                cols.a[i].populate(
-                    event.channel,
-                    event.a_reads_writes[i],
-                    &mut new_byte_lookup_events,
-                );
-
-                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
-
-                let a = event.a_reads_writes[i].value;
-                let b = event.b_reads[i].value;
-                let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
-                assert_eq!(a ^ b, xor);
-
-                let rotate_right =
-                    cols.rotate_right[i].populate(output, shard, event.channel, xor, R_2 as usize);
-                assert_eq!(xor.rotate_right(R_2), rotate_right);
-            }
-
-            rows.push(row);
-        }
-
-        output.add_byte_lookup_events(new_byte_lookup_events);
-
-        pad_rows(&mut rows, || {
-            let row = vec![F::zero(); width];
-
-            row
-        });
-
-        let mut trace =
-            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
-
-        // Write the nonces to the trace.
-        for i in 0..trace.height() {
-            let cols: &mut Blake2sXorRotateRight12Cols<F> =
-                trace.values[i * width..(i + 1) * width].borrow_mut();
-            cols.nonce = F::from_canonical_usize(i);
-        }
-
-        trace
-    }
-
-    fn included(&self, shard: &Self::Record) -> bool {
-        !shard.blake2s_xor_rotate_right_12_events.is_empty()
-    }
-}
-
-impl<AB: SphinxAirBuilder> Air<AB> for Blake2sXorRotateRight12Chip
-where
-    AB::F: PrimeField32,
-{
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let local = main.row_slice(0);
-        let next = main.row_slice(1);
-        let local: &Blake2sXorRotateRight12Cols<AB::Var> = (*local).borrow();
-        let next: &Blake2sXorRotateRight12Cols<AB::Var> = (*next).borrow();
-
-        // Constrain the incrementing nonce.
-        builder.when_first_row().assert_zero(local.nonce);
-        builder
-            .when_transition()
-            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
-
-        for i in 0..4usize {
-            // Eval a
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
-                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.a[i],
-                local.is_real,
-            );
-
-            // Eval b.
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
-                local.is_real,
-            );
-
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                *local.a[i].value(),
-                *local.b[i].value(),
-                local.xor[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i].value,
-                R_2 as usize,
-                local.rotate_right[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-        }
-
-        builder.receive_syscall(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12.syscall_id()),
-            local.a_ptr,
-            local.b_ptr,
-            local.is_real,
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::BLAKE2S_XOR_ROTATE_RIGHT_12_ELF;
-    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
-    use crate::Program;
-
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
-        let mut instructions = vec![];
-        // memory write a
-        for (index, word) in a.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                a_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // memory write b
-        for (index, word) in b.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                b_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // Syscall invocation
-        instructions.push(Instruction::new(
-            Opcode::ADD,
-            5,
-            0,
-            SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_12 as u32,
-            false,
-            true,
-        ));
-        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
-        Program::new(instructions, 0, 0)
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_right_12_precompile() {
-        setup_logger();
-
-        let a_ptr = 100100100;
-        let b_ptr = 200200200;
-        let program = risc_v_program(
-            a_ptr,
-            b_ptr,
-            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
-        );
-
-        let (_, memory) = run_test_with_memory_inspection(program);
-        let mut result = vec![];
-        // result is 4 words, written to a_ptr
-        for i in 0..4 {
-            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
-        }
-
-        assert_eq!(
-            result,
-            [0x4383a06b, 0x6092062c, 0xad923ed2, 0x823feaf3].to_vec()
-        );
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_right_16_program() {
-        setup_logger();
-        let program = Program::from(BLAKE2S_XOR_ROTATE_RIGHT_12_ELF);
-        run_test(program).unwrap();
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_right_16.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_right_16.rs
deleted file mode 100644
index e836585e0..000000000
--- a/core/src/syscall/precompiles/blake2s/xor_rotate_right_16.rs
+++ /dev/null
@@ -1,357 +0,0 @@
-use crate::bytes::event::ByteRecord;
-use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::{FixedRotateRightOperation, XorOperation};
-use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
-use crate::stark::SphinxAirBuilder;
-use crate::utils::pad_rows;
-use crate::{
-    air::{EventLens, MachineAir, WithEvents},
-    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
-};
-use core::borrow::{Borrow, BorrowMut};
-use p3_air::{Air, AirBuilder, BaseAir};
-use p3_field::{AbstractField, PrimeField32};
-use p3_matrix::dense::RowMajorMatrix;
-use p3_matrix::Matrix;
-use serde::Deserialize;
-use serde::Serialize;
-use sphinx_derive::AlignedBorrow;
-use std::mem::size_of;
-
-const R_1: u32 = 16;
-
-#[derive(Default)]
-pub struct Blake2sXorRotateRight16Chip;
-
-impl Blake2sXorRotateRight16Chip {
-    pub fn new() -> Self {
-        Blake2sXorRotateRight16Chip
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Blake2sXorRotateRight16Event {
-    pub lookup_id: usize,
-    pub clk: u32,
-    pub shard: u32,
-    pub channel: u32,
-    pub a_ptr: u32,
-    pub b_ptr: u32,
-    pub a_reads_writes: Vec<MemoryWriteRecord>,
-    pub b_reads: Vec<MemoryReadRecord>,
-}
-
-impl Syscall for Blake2sXorRotateRight16Chip {
-    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
-        let clk_init = ctx.clk;
-        let shard = ctx.current_shard();
-        let lookup_id = ctx.syscall_lookup_id;
-        let channel = ctx.current_channel();
-
-        let a_ptr = arg1;
-        let b_ptr = arg2;
-
-        let a = ctx.slice_unsafe(a_ptr, 4);
-        let (b_reads, b) = ctx.mr_slice(b_ptr, 4);
-
-        let xor = a
-            .into_iter()
-            .zip(b.into_iter())
-            .map(|(a, b)| a ^ b)
-            .collect::<Vec<u32>>();
-
-        let rotate_right = xor
-            .into_iter()
-            .map(|xor_i| xor_i.rotate_right(R_1))
-            .collect::<Vec<u32>>();
-
-        ctx.clk += 1;
-
-        // Write rotate_right to a_ptr.
-        let a_reads_writes = ctx.mw_slice(a_ptr, rotate_right.as_slice());
-
-        ctx.record_mut()
-            .blake2s_xor_rotate_right_16_events
-            .push(Blake2sXorRotateRight16Event {
-                lookup_id,
-                clk: clk_init,
-                shard,
-                channel,
-                a_ptr,
-                b_ptr,
-                a_reads_writes,
-                b_reads,
-            });
-
-        None
-    }
-
-    fn num_extra_cycles(&self) -> u32 {
-        1
-    }
-}
-
-#[derive(Debug, Clone, AlignedBorrow)]
-#[repr(C)]
-struct Blake2sXorRotateRight16Cols<T> {
-    pub clk: T,
-    pub shard: T,
-    pub channel: T,
-    pub nonce: T,
-    pub is_real: T,
-
-    pub a_ptr: T,
-    pub b_ptr: T,
-
-    pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 4],
-
-    pub xor: [XorOperation<T>; 4],
-    pub rotate_right: [FixedRotateRightOperation<T>; 4],
-}
-
-impl<T: PrimeField32> BaseAir<T> for Blake2sXorRotateRight16Chip {
-    fn width(&self) -> usize {
-        size_of::<Blake2sXorRotateRight16Cols<u8>>()
-    }
-}
-
-impl<'a> WithEvents<'a> for Blake2sXorRotateRight16Chip {
-    type Events = &'a [Blake2sXorRotateRight16Event];
-}
-
-impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRight16Chip {
-    type Record = ExecutionRecord;
-    type Program = Program;
-
-    fn name(&self) -> String {
-        "Blake2sXorRotateRight16Chip".to_string()
-    }
-
-    fn generate_trace<EL: EventLens<Self>>(
-        &self,
-        input: &EL,
-        output: &mut Self::Record,
-    ) -> RowMajorMatrix<F> {
-        let mut rows = vec![];
-        let width = <Blake2sXorRotateRight16Chip as BaseAir<F>>::width(self);
-        let mut new_byte_lookup_events = Vec::new();
-        for event in input.events() {
-            let shard = event.shard;
-            let mut row = vec![F::zero(); width];
-            let cols: &mut Blake2sXorRotateRight16Cols<F> = row.as_mut_slice().borrow_mut();
-
-            cols.clk = F::from_canonical_u32(event.clk);
-            cols.is_real = F::one();
-            cols.shard = F::from_canonical_u32(event.shard);
-            cols.channel = F::from_canonical_u32(event.channel);
-            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
-            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
-
-            for i in 0..4usize {
-                cols.a[i].populate(
-                    event.channel,
-                    event.a_reads_writes[i],
-                    &mut new_byte_lookup_events,
-                );
-
-                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
-
-                let a = event.a_reads_writes[i].value;
-                let b = event.b_reads[i].value;
-                let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
-                assert_eq!(a ^ b, xor);
-
-                let rotate_right =
-                    cols.rotate_right[i].populate(output, shard, event.channel, xor, R_1 as usize);
-                assert_eq!(xor.rotate_right(R_1), rotate_right);
-            }
-
-            rows.push(row);
-        }
-
-        output.add_byte_lookup_events(new_byte_lookup_events);
-
-        pad_rows(&mut rows, || {
-            let row = vec![F::zero(); width];
-
-            row
-        });
-
-        let mut trace =
-            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
-
-        // Write the nonces to the trace.
-        for i in 0..trace.height() {
-            let cols: &mut Blake2sXorRotateRight16Cols<F> =
-                trace.values[i * width..(i + 1) * width].borrow_mut();
-            cols.nonce = F::from_canonical_usize(i);
-        }
-
-        trace
-    }
-
-    fn included(&self, shard: &Self::Record) -> bool {
-        !shard.blake2s_xor_rotate_right_16_events.is_empty()
-    }
-}
-
-impl<AB: SphinxAirBuilder> Air<AB> for Blake2sXorRotateRight16Chip
-where
-    AB::F: PrimeField32,
-{
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let local = main.row_slice(0);
-        let next = main.row_slice(1);
-        let local: &Blake2sXorRotateRight16Cols<AB::Var> = (*local).borrow();
-        let next: &Blake2sXorRotateRight16Cols<AB::Var> = (*next).borrow();
-
-        // Constrain the incrementing nonce.
-        builder.when_first_row().assert_zero(local.nonce);
-        builder
-            .when_transition()
-            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
-
-        for i in 0..4usize {
-            // Eval a
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
-                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.a[i],
-                local.is_real,
-            );
-
-            // Eval b.
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
-                local.is_real,
-            );
-
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                *local.a[i].value(),
-                *local.b[i].value(),
-                local.xor[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i].value,
-                R_1 as usize,
-                local.rotate_right[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-        }
-
-        builder.receive_syscall(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_16.syscall_id()),
-            local.a_ptr,
-            local.b_ptr,
-            local.is_real,
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::BLAKE2S_XOR_ROTATE_RIGHT_16_ELF;
-    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
-    use crate::Program;
-
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
-        let mut instructions = vec![];
-        // memory write a
-        for (index, word) in a.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                a_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // memory write b
-        for (index, word) in b.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                b_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // Syscall invocation
-        instructions.push(Instruction::new(
-            Opcode::ADD,
-            5,
-            0,
-            SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_16 as u32,
-            false,
-            true,
-        ));
-        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
-        Program::new(instructions, 0, 0)
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_right_16_precompile() {
-        setup_logger();
-
-        let a_ptr = 100100100;
-        let b_ptr = 200200200;
-        let program = risc_v_program(
-            a_ptr,
-            b_ptr,
-            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
-        );
-
-        let (_, memory) = run_test_with_memory_inspection(program);
-        let mut result = vec![];
-        // result is 4 words, written to a_ptr
-        for i in 0..4 {
-            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
-        }
-
-        assert_eq!(
-            result,
-            [0xb4383a06, 0xc6092062, 0x2ad923ed, 0x3823feaf].to_vec()
-        );
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_right_16_program() {
-        setup_logger();
-        let program = Program::from(BLAKE2S_XOR_ROTATE_RIGHT_16_ELF);
-        run_test(program).unwrap();
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_right_7.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_right_7.rs
deleted file mode 100644
index 387dc7e5f..000000000
--- a/core/src/syscall/precompiles/blake2s/xor_rotate_right_7.rs
+++ /dev/null
@@ -1,357 +0,0 @@
-use crate::bytes::event::ByteRecord;
-use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::{FixedRotateRightOperation, XorOperation};
-use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
-use crate::stark::SphinxAirBuilder;
-use crate::utils::pad_rows;
-use crate::{
-    air::{EventLens, MachineAir, WithEvents},
-    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
-};
-use core::borrow::{Borrow, BorrowMut};
-use p3_air::{Air, AirBuilder, BaseAir};
-use p3_field::{AbstractField, PrimeField32};
-use p3_matrix::dense::RowMajorMatrix;
-use p3_matrix::Matrix;
-use serde::Deserialize;
-use serde::Serialize;
-use sphinx_derive::AlignedBorrow;
-use std::mem::size_of;
-
-const R_4: u32 = 7;
-
-#[derive(Default)]
-pub struct Blake2sXorRotateRight7Chip;
-
-impl Blake2sXorRotateRight7Chip {
-    pub fn new() -> Self {
-        Blake2sXorRotateRight7Chip
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Blake2sXorRotateRight7Event {
-    pub lookup_id: usize,
-    pub clk: u32,
-    pub shard: u32,
-    pub channel: u32,
-    pub a_ptr: u32,
-    pub b_ptr: u32,
-    pub a_reads_writes: Vec<MemoryWriteRecord>,
-    pub b_reads: Vec<MemoryReadRecord>,
-}
-
-impl Syscall for Blake2sXorRotateRight7Chip {
-    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
-        let clk_init = ctx.clk;
-        let shard = ctx.current_shard();
-        let lookup_id = ctx.syscall_lookup_id;
-        let channel = ctx.current_channel();
-
-        let a_ptr = arg1;
-        let b_ptr = arg2;
-
-        let a = ctx.slice_unsafe(a_ptr, 4);
-        let (b_reads, b) = ctx.mr_slice(b_ptr, 4);
-
-        let xor = a
-            .into_iter()
-            .zip(b.into_iter())
-            .map(|(a, b)| a ^ b)
-            .collect::<Vec<u32>>();
-
-        let rotate_right = xor
-            .into_iter()
-            .map(|xor_i| xor_i.rotate_right(R_4))
-            .collect::<Vec<u32>>();
-
-        ctx.clk += 1;
-
-        // Write rotate_right to a_ptr.
-        let a_reads_writes = ctx.mw_slice(a_ptr, rotate_right.as_slice());
-
-        ctx.record_mut()
-            .blake2s_xor_rotate_right_7_events
-            .push(Blake2sXorRotateRight7Event {
-                lookup_id,
-                clk: clk_init,
-                shard,
-                channel,
-                a_ptr,
-                b_ptr,
-                a_reads_writes,
-                b_reads,
-            });
-
-        None
-    }
-
-    fn num_extra_cycles(&self) -> u32 {
-        1
-    }
-}
-
-#[derive(Debug, Clone, AlignedBorrow)]
-#[repr(C)]
-struct Blake2sXorRotateRight7Cols<T> {
-    pub clk: T,
-    pub shard: T,
-    pub channel: T,
-    pub nonce: T,
-    pub is_real: T,
-
-    pub a_ptr: T,
-    pub b_ptr: T,
-
-    pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 4],
-
-    pub xor: [XorOperation<T>; 4],
-    pub rotate_right: [FixedRotateRightOperation<T>; 4],
-}
-
-impl<T: PrimeField32> BaseAir<T> for Blake2sXorRotateRight7Chip {
-    fn width(&self) -> usize {
-        size_of::<Blake2sXorRotateRight7Cols<u8>>()
-    }
-}
-
-impl<'a> WithEvents<'a> for Blake2sXorRotateRight7Chip {
-    type Events = &'a [Blake2sXorRotateRight7Event];
-}
-
-impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRight7Chip {
-    type Record = ExecutionRecord;
-    type Program = Program;
-
-    fn name(&self) -> String {
-        "Blake2sXorRotateRight7Chip".to_string()
-    }
-
-    fn generate_trace<EL: EventLens<Self>>(
-        &self,
-        input: &EL,
-        output: &mut Self::Record,
-    ) -> RowMajorMatrix<F> {
-        let mut rows = vec![];
-        let width = <Blake2sXorRotateRight7Chip as BaseAir<F>>::width(self);
-        let mut new_byte_lookup_events = Vec::new();
-        for event in input.events() {
-            let shard = event.shard;
-            let mut row = vec![F::zero(); width];
-            let cols: &mut Blake2sXorRotateRight7Cols<F> = row.as_mut_slice().borrow_mut();
-
-            cols.clk = F::from_canonical_u32(event.clk);
-            cols.is_real = F::one();
-            cols.shard = F::from_canonical_u32(event.shard);
-            cols.channel = F::from_canonical_u32(event.channel);
-            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
-            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
-
-            for i in 0..4usize {
-                cols.a[i].populate(
-                    event.channel,
-                    event.a_reads_writes[i],
-                    &mut new_byte_lookup_events,
-                );
-
-                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
-
-                let a = event.a_reads_writes[i].value;
-                let b = event.b_reads[i].value;
-                let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
-                assert_eq!(a ^ b, xor);
-
-                let rotate_right =
-                    cols.rotate_right[i].populate(output, shard, event.channel, xor, R_4 as usize);
-                assert_eq!(xor.rotate_right(R_4), rotate_right);
-            }
-
-            rows.push(row);
-        }
-
-        output.add_byte_lookup_events(new_byte_lookup_events);
-
-        pad_rows(&mut rows, || {
-            let row = vec![F::zero(); width];
-
-            row
-        });
-
-        let mut trace =
-            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
-
-        // Write the nonces to the trace.
-        for i in 0..trace.height() {
-            let cols: &mut Blake2sXorRotateRight7Cols<F> =
-                trace.values[i * width..(i + 1) * width].borrow_mut();
-            cols.nonce = F::from_canonical_usize(i);
-        }
-
-        trace
-    }
-
-    fn included(&self, shard: &Self::Record) -> bool {
-        !shard.blake2s_xor_rotate_right_7_events.is_empty()
-    }
-}
-
-impl<AB: SphinxAirBuilder> Air<AB> for Blake2sXorRotateRight7Chip
-where
-    AB::F: PrimeField32,
-{
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let local = main.row_slice(0);
-        let next = main.row_slice(1);
-        let local: &Blake2sXorRotateRight7Cols<AB::Var> = (*local).borrow();
-        let next: &Blake2sXorRotateRight7Cols<AB::Var> = (*next).borrow();
-
-        // Constrain the incrementing nonce.
-        builder.when_first_row().assert_zero(local.nonce);
-        builder
-            .when_transition()
-            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
-
-        for i in 0..4usize {
-            // Eval a
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
-                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.a[i],
-                local.is_real,
-            );
-
-            // Eval b.
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
-                local.is_real,
-            );
-
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                *local.a[i].value(),
-                *local.b[i].value(),
-                local.xor[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i].value,
-                R_4 as usize,
-                local.rotate_right[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-        }
-
-        builder.receive_syscall(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7.syscall_id()),
-            local.a_ptr,
-            local.b_ptr,
-            local.is_real,
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::BLAKE2S_XOR_ROTATE_RIGHT_7_ELF;
-    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
-    use crate::Program;
-
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
-        let mut instructions = vec![];
-        // memory write a
-        for (index, word) in a.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                a_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // memory write b
-        for (index, word) in b.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                b_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // Syscall invocation
-        instructions.push(Instruction::new(
-            Opcode::ADD,
-            5,
-            0,
-            SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_7 as u32,
-            false,
-            true,
-        ));
-        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
-        Program::new(instructions, 0, 0)
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_right_7_precompile() {
-        setup_logger();
-
-        let a_ptr = 100100100;
-        let b_ptr = 200200200;
-        let program = risc_v_program(
-            a_ptr,
-            b_ptr,
-            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
-        );
-
-        let (_, memory) = run_test_with_memory_inspection(program);
-        let mut result = vec![];
-        // result is 4 words, written to a_ptr
-        for i in 0..4 {
-            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
-        }
-
-        assert_eq!(
-            result,
-            [0x70740d68, 0x1240c58c, 0xb247da55, 0x47fd5e70].to_vec()
-        );
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_right_7_program() {
-        setup_logger();
-        let program = Program::from(BLAKE2S_XOR_ROTATE_RIGHT_7_ELF);
-        run_test(program).unwrap();
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/xor_rotate_right_8.rs b/core/src/syscall/precompiles/blake2s/xor_rotate_right_8.rs
deleted file mode 100644
index 101a9673a..000000000
--- a/core/src/syscall/precompiles/blake2s/xor_rotate_right_8.rs
+++ /dev/null
@@ -1,357 +0,0 @@
-use crate::bytes::event::ByteRecord;
-use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::{FixedRotateRightOperation, XorOperation};
-use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
-use crate::stark::SphinxAirBuilder;
-use crate::utils::pad_rows;
-use crate::{
-    air::{EventLens, MachineAir, WithEvents},
-    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
-};
-use core::borrow::{Borrow, BorrowMut};
-use p3_air::{Air, AirBuilder, BaseAir};
-use p3_field::{AbstractField, PrimeField32};
-use p3_matrix::dense::RowMajorMatrix;
-use p3_matrix::Matrix;
-use serde::Deserialize;
-use serde::Serialize;
-use sphinx_derive::AlignedBorrow;
-use std::mem::size_of;
-
-const R_3: u32 = 8;
-
-#[derive(Default)]
-pub struct Blake2sXorRotateRight8Chip;
-
-impl Blake2sXorRotateRight8Chip {
-    pub fn new() -> Self {
-        Blake2sXorRotateRight8Chip
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Blake2sXorRotateRight8Event {
-    pub lookup_id: usize,
-    pub clk: u32,
-    pub shard: u32,
-    pub channel: u32,
-    pub a_ptr: u32,
-    pub b_ptr: u32,
-    pub a_reads_writes: Vec<MemoryWriteRecord>,
-    pub b_reads: Vec<MemoryReadRecord>,
-}
-
-impl Syscall for Blake2sXorRotateRight8Chip {
-    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
-        let clk_init = ctx.clk;
-        let shard = ctx.current_shard();
-        let lookup_id = ctx.syscall_lookup_id;
-        let channel = ctx.current_channel();
-
-        let a_ptr = arg1;
-        let b_ptr = arg2;
-
-        let a = ctx.slice_unsafe(a_ptr, 4);
-        let (b_reads, b) = ctx.mr_slice(b_ptr, 4);
-
-        let xor = a
-            .into_iter()
-            .zip(b.into_iter())
-            .map(|(a, b)| a ^ b)
-            .collect::<Vec<u32>>();
-
-        let rotate_right = xor
-            .into_iter()
-            .map(|xor_i| xor_i.rotate_right(R_3))
-            .collect::<Vec<u32>>();
-
-        ctx.clk += 1;
-
-        // Write rotate_right to a_ptr.
-        let a_reads_writes = ctx.mw_slice(a_ptr, rotate_right.as_slice());
-
-        ctx.record_mut()
-            .blake2s_xor_rotate_right_8_events
-            .push(Blake2sXorRotateRight8Event {
-                lookup_id,
-                clk: clk_init,
-                shard,
-                channel,
-                a_ptr,
-                b_ptr,
-                a_reads_writes,
-                b_reads,
-            });
-
-        None
-    }
-
-    fn num_extra_cycles(&self) -> u32 {
-        1
-    }
-}
-
-#[derive(Debug, Clone, AlignedBorrow)]
-#[repr(C)]
-struct Blake2sXorRotateRight8Cols<T> {
-    pub clk: T,
-    pub shard: T,
-    pub channel: T,
-    pub nonce: T,
-    pub is_real: T,
-
-    pub a_ptr: T,
-    pub b_ptr: T,
-
-    pub a: [MemoryWriteCols<T>; 4],
-    pub b: [MemoryReadCols<T>; 4],
-
-    pub xor: [XorOperation<T>; 4],
-    pub rotate_right: [FixedRotateRightOperation<T>; 4],
-}
-
-impl<T: PrimeField32> BaseAir<T> for Blake2sXorRotateRight8Chip {
-    fn width(&self) -> usize {
-        size_of::<Blake2sXorRotateRight8Cols<u8>>()
-    }
-}
-
-impl<'a> WithEvents<'a> for Blake2sXorRotateRight8Chip {
-    type Events = &'a [Blake2sXorRotateRight8Event];
-}
-
-impl<F: PrimeField32> MachineAir<F> for Blake2sXorRotateRight8Chip {
-    type Record = ExecutionRecord;
-    type Program = Program;
-
-    fn name(&self) -> String {
-        "Blake2sXorRotateRight8Chip".to_string()
-    }
-
-    fn generate_trace<EL: EventLens<Self>>(
-        &self,
-        input: &EL,
-        output: &mut Self::Record,
-    ) -> RowMajorMatrix<F> {
-        let mut rows = vec![];
-        let width = <Blake2sXorRotateRight8Chip as BaseAir<F>>::width(self);
-        let mut new_byte_lookup_events = Vec::new();
-        for event in input.events() {
-            let shard = event.shard;
-            let mut row = vec![F::zero(); width];
-            let cols: &mut Blake2sXorRotateRight8Cols<F> = row.as_mut_slice().borrow_mut();
-
-            cols.clk = F::from_canonical_u32(event.clk);
-            cols.is_real = F::one();
-            cols.shard = F::from_canonical_u32(event.shard);
-            cols.channel = F::from_canonical_u32(event.channel);
-            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
-            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
-
-            for i in 0..4usize {
-                cols.a[i].populate(
-                    event.channel,
-                    event.a_reads_writes[i],
-                    &mut new_byte_lookup_events,
-                );
-
-                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
-
-                let a = event.a_reads_writes[i].value;
-                let b = event.b_reads[i].value;
-                let xor = cols.xor[i].populate(output, shard, event.channel, a, b);
-                assert_eq!(a ^ b, xor);
-
-                let rotate_right =
-                    cols.rotate_right[i].populate(output, shard, event.channel, xor, R_3 as usize);
-                assert_eq!(xor.rotate_right(R_3), rotate_right);
-            }
-
-            rows.push(row);
-        }
-
-        output.add_byte_lookup_events(new_byte_lookup_events);
-
-        pad_rows(&mut rows, || {
-            let row = vec![F::zero(); width];
-
-            row
-        });
-
-        let mut trace =
-            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
-
-        // Write the nonces to the trace.
-        for i in 0..trace.height() {
-            let cols: &mut Blake2sXorRotateRight8Cols<F> =
-                trace.values[i * width..(i + 1) * width].borrow_mut();
-            cols.nonce = F::from_canonical_usize(i);
-        }
-
-        trace
-    }
-
-    fn included(&self, shard: &Self::Record) -> bool {
-        !shard.blake2s_xor_rotate_right_8_events.is_empty()
-    }
-}
-
-impl<AB: SphinxAirBuilder> Air<AB> for Blake2sXorRotateRight8Chip
-where
-    AB::F: PrimeField32,
-{
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let local = main.row_slice(0);
-        let next = main.row_slice(1);
-        let local: &Blake2sXorRotateRight8Cols<AB::Var> = (*local).borrow();
-        let next: &Blake2sXorRotateRight8Cols<AB::Var> = (*next).borrow();
-
-        // Constrain the incrementing nonce.
-        builder.when_first_row().assert_zero(local.nonce);
-        builder
-            .when_transition()
-            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
-
-        for i in 0..4usize {
-            // Eval a
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
-                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.a[i],
-                local.is_real,
-            );
-
-            // Eval b.
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
-                local.is_real,
-            );
-
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                *local.a[i].value(),
-                *local.b[i].value(),
-                local.xor[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i].value,
-                R_3 as usize,
-                local.rotate_right[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-        }
-
-        builder.receive_syscall(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8.syscall_id()),
-            local.a_ptr,
-            local.b_ptr,
-            local.is_real,
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::utils::tests::BLAKE2S_XOR_ROTATE_RIGHT_8_ELF;
-    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
-    use crate::Program;
-
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 4], b: [u32; 4]) -> Program {
-        let mut instructions = vec![];
-        // memory write a
-        for (index, word) in a.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                a_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // memory write b
-        for (index, word) in b.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                b_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // Syscall invocation
-        instructions.push(Instruction::new(
-            Opcode::ADD,
-            5,
-            0,
-            SyscallCode::BLAKE_2S_XOR_ROTATE_RIGHT_8 as u32,
-            false,
-            true,
-        ));
-        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
-        Program::new(instructions, 0, 0)
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_right_8_precompile() {
-        setup_logger();
-
-        let a_ptr = 100100100;
-        let b_ptr = 200200200;
-        let program = risc_v_program(
-            a_ptr,
-            b_ptr,
-            [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a],
-            [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19],
-        );
-
-        let (_, memory) = run_test_with_memory_inspection(program);
-        let mut result = vec![];
-        // result is 4 words, written to a_ptr
-        for i in 0..4 {
-            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
-        }
-
-        assert_eq!(
-            result,
-            [0x383a06b4, 0x92062c6, 0xd923ed2a, 0x23feaf38].to_vec()
-        );
-    }
-
-    #[test]
-    fn test_blake2s_xor_rotate_right_8_program() {
-        setup_logger();
-        let program = Program::from(BLAKE2S_XOR_ROTATE_RIGHT_8_ELF);
-        run_test(program).unwrap();
-    }
-}
diff --git a/core/src/utils/programs.rs b/core/src/utils/programs.rs
index 5b90fc220..8e5b3dd3c 100644
--- a/core/src/utils/programs.rs
+++ b/core/src/utils/programs.rs
@@ -121,29 +121,6 @@ pub mod tests {
     pub const BLS12381_G2_DOUBLE_ELF: &[u8] =
         include_bytes!("../../../tests/bls12381-g2-double/elf/riscv32im-succinct-zkvm-elf");
 
-    pub const BLAKE2S_XOR_ROTATE_RIGHT_16_ELF: &[u8] = include_bytes!(
-        "../../../tests/blake2s-xor-rotate-right-16/elf/riscv32im-succinct-zkvm-elf"
-    );
-
-    pub const BLAKE2S_XOR_RIGHT_16_ELF: &[u8] =
-        include_bytes!("../../../tests/blake2s-xor-rotate-16/elf/riscv32im-succinct-zkvm-elf");
-
-    pub const BLAKE2S_ADD_2_ELF: &[u8] =
-        include_bytes!("../../../tests/blake2s-add2/elf/riscv32im-succinct-zkvm-elf");
-
-    pub const BLAKE2S_ADD_3_ELF: &[u8] =
-        include_bytes!("../../../tests/blake2s-add3/elf/riscv32im-succinct-zkvm-elf");
-
-    pub const BLAKE2S_XOR_ROTATE_RIGHT_12_ELF: &[u8] = include_bytes!(
-        "../../../tests/blake2s-xor-rotate-right-12/elf/riscv32im-succinct-zkvm-elf"
-    );
-
-    pub const BLAKE2S_XOR_ROTATE_RIGHT_8_ELF: &[u8] =
-        include_bytes!("../../../tests/blake2s-xor-rotate-right-8/elf/riscv32im-succinct-zkvm-elf");
-
-    pub const BLAKE2S_XOR_ROTATE_RIGHT_7_ELF: &[u8] =
-        include_bytes!("../../../tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf");
-
     pub const BLAKE2S_ROUND_ELF: &[u8] =
         include_bytes!("../../../tests/blake2s-round/elf/riscv32im-succinct-zkvm-elf");
 
diff --git a/tests/blake2s-add2/Cargo.lock b/tests/blake2s-add2/Cargo.lock
deleted file mode 100644
index b0f99b12f..000000000
--- a/tests/blake2s-add2/Cargo.lock
+++ /dev/null
@@ -1,539 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "anyhow"
-version = "1.0.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
-
-[[package]]
-name = "base16ct"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
-
-[[package]]
-name = "base64ct"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
-
-[[package]]
-name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "blake2s-add2"
-version = "0.1.0"
-dependencies = [
- "sphinx-zkvm",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crypto-bigint"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
-dependencies = [
- "generic-array",
- "rand_core",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "der"
-version = "0.7.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
-dependencies = [
- "const-oid",
- "zeroize",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "const-oid",
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "ecdsa"
-version = "0.16.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
-dependencies = [
- "der",
- "digest",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
-]
-
-[[package]]
-name = "elliptic-curve"
-version = "0.13.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
-dependencies = [
- "base16ct",
- "crypto-bigint",
- "digest",
- "ff",
- "generic-array",
- "group",
- "pkcs8",
- "rand_core",
- "sec1",
- "subtle",
- "tap",
- "zeroize",
-]
-
-[[package]]
-name = "ff"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
-dependencies = [
- "bitvec",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
- "zeroize",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "group"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
-dependencies = [
- "ff",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "hybrid-array"
-version = "0.2.0-rc.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "k256"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "once_cell",
- "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "signature",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
-[[package]]
-name = "libc"
-version = "0.2.158"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
-
-[[package]]
-name = "libm"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
-
-[[package]]
-name = "once_cell"
-version = "1.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rfc6979"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
-dependencies = [
- "hmac",
- "subtle",
-]
-
-[[package]]
-name = "sec1"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
-dependencies = [
- "base16ct",
- "der",
- "generic-array",
- "pkcs8",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "signature"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
-dependencies = [
- "digest",
- "rand_core",
-]
-
-[[package]]
-name = "sphinx-precompiles"
-version = "1.0.0"
-dependencies = [
- "anyhow",
- "bincode",
- "cfg-if",
- "getrandom",
- "hybrid-array",
- "k256",
- "serde",
-]
-
-[[package]]
-name = "sphinx-zkvm"
-version = "1.0.0"
-dependencies = [
- "bincode",
- "cfg-if",
- "getrandom",
- "k256",
- "lazy_static",
- "libm",
- "once_cell",
- "rand",
- "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
- "sphinx-precompiles",
-]
-
-[[package]]
-name = "spki"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
-dependencies = [
- "base64ct",
- "der",
-]
-
-[[package]]
-name = "subtle"
-version = "2.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
-
-[[package]]
-name = "syn"
-version = "2.0.77"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "typenum"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
-
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wyz"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
-
-[[package]]
-name = "zerocopy"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
-dependencies = [
- "byteorder",
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "zeroize"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-add2/Cargo.toml b/tests/blake2s-add2/Cargo.toml
deleted file mode 100644
index 758f44ab5..000000000
--- a/tests/blake2s-add2/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[workspace]
-[package]
-name = "blake2s-add2"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-add2/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-add2/elf/riscv32im-succinct-zkvm-elf
deleted file mode 100755
index 72bd6da466349987f8f21fc79afbe3761cd08c67..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 25140
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

diff --git a/tests/blake2s-add2/src/main.rs b/tests/blake2s-add2/src/main.rs
deleted file mode 100644
index b3bf5661e..000000000
--- a/tests/blake2s-add2/src/main.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![no_main]
-sphinx_zkvm::entrypoint!(main);
-
-use sphinx_zkvm::syscalls::blake2s_add_2::syscall_blake2s_add_2;
-
-pub fn main() {
-    let mut a: [u32; 4] = [200, 300, 400, 500];
-    let b: [u32; 12] = [10, 20, 30, 40, 0, 0, 0, 0, 0, 0, 0, 0];
-
-    syscall_blake2s_add_2(a.as_mut_ptr(), b.as_ptr());
-
-    assert_eq!(a, [210, 320, 430, 540]);
-}
diff --git a/tests/blake2s-add3/Cargo.lock b/tests/blake2s-add3/Cargo.lock
deleted file mode 100644
index d92fcf456..000000000
--- a/tests/blake2s-add3/Cargo.lock
+++ /dev/null
@@ -1,539 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "anyhow"
-version = "1.0.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
-
-[[package]]
-name = "base16ct"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
-
-[[package]]
-name = "base64ct"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
-
-[[package]]
-name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "blake2s-add3"
-version = "0.1.0"
-dependencies = [
- "sphinx-zkvm",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crypto-bigint"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
-dependencies = [
- "generic-array",
- "rand_core",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "der"
-version = "0.7.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
-dependencies = [
- "const-oid",
- "zeroize",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "const-oid",
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "ecdsa"
-version = "0.16.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
-dependencies = [
- "der",
- "digest",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
-]
-
-[[package]]
-name = "elliptic-curve"
-version = "0.13.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
-dependencies = [
- "base16ct",
- "crypto-bigint",
- "digest",
- "ff",
- "generic-array",
- "group",
- "pkcs8",
- "rand_core",
- "sec1",
- "subtle",
- "tap",
- "zeroize",
-]
-
-[[package]]
-name = "ff"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
-dependencies = [
- "bitvec",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
- "zeroize",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "group"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
-dependencies = [
- "ff",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "hybrid-array"
-version = "0.2.0-rc.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "k256"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "once_cell",
- "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "signature",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
-[[package]]
-name = "libc"
-version = "0.2.158"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
-
-[[package]]
-name = "libm"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
-
-[[package]]
-name = "once_cell"
-version = "1.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rfc6979"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
-dependencies = [
- "hmac",
- "subtle",
-]
-
-[[package]]
-name = "sec1"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
-dependencies = [
- "base16ct",
- "der",
- "generic-array",
- "pkcs8",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "signature"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
-dependencies = [
- "digest",
- "rand_core",
-]
-
-[[package]]
-name = "sphinx-precompiles"
-version = "1.0.0"
-dependencies = [
- "anyhow",
- "bincode",
- "cfg-if",
- "getrandom",
- "hybrid-array",
- "k256",
- "serde",
-]
-
-[[package]]
-name = "sphinx-zkvm"
-version = "1.0.0"
-dependencies = [
- "bincode",
- "cfg-if",
- "getrandom",
- "k256",
- "lazy_static",
- "libm",
- "once_cell",
- "rand",
- "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
- "sphinx-precompiles",
-]
-
-[[package]]
-name = "spki"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
-dependencies = [
- "base64ct",
- "der",
-]
-
-[[package]]
-name = "subtle"
-version = "2.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
-
-[[package]]
-name = "syn"
-version = "2.0.77"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "typenum"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
-
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wyz"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
-
-[[package]]
-name = "zerocopy"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
-dependencies = [
- "byteorder",
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "zeroize"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-add3/Cargo.toml b/tests/blake2s-add3/Cargo.toml
deleted file mode 100644
index b1777b692..000000000
--- a/tests/blake2s-add3/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[workspace]
-[package]
-name = "blake2s-add3"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-add3/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-add3/elf/riscv32im-succinct-zkvm-elf
deleted file mode 100755
index ceef83ebba42ef5ac943d2a8ec0830351784ae26..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 25156
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
Avj6}9

diff --git a/tests/blake2s-add3/src/main.rs b/tests/blake2s-add3/src/main.rs
deleted file mode 100644
index 594c4e344..000000000
--- a/tests/blake2s-add3/src/main.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![no_main]
-sphinx_zkvm::entrypoint!(main);
-
-use sphinx_zkvm::syscalls::blake2s_add_3::syscall_blake2s_add_3;
-
-pub fn main() {
-    let mut a: [u32; 4] = [200, 300, 400, 500];
-    let b: [u32; 12] = [10, 20, 30, 40, 1, 2, 3, 4, 0, 0, 0, 0];
-
-    syscall_blake2s_add_3(a.as_mut_ptr(), b.as_ptr());
-
-    assert_eq!(a, [211, 322, 433, 544]);
-}
diff --git a/tests/blake2s-round/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-round/elf/riscv32im-succinct-zkvm-elf
index dad5a964e749b5533e34c044b8afc7f8ad93101e..d20fc7e4394539b95ec58368a5f2c68ef66e49f8 100755
GIT binary patch
delta 6422
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

delta 9076
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

diff --git a/tests/blake2s-round/src/main.rs b/tests/blake2s-round/src/main.rs
index 7ab5a38e0..c67c53605 100644
--- a/tests/blake2s-round/src/main.rs
+++ b/tests/blake2s-round/src/main.rs
@@ -1,7 +1,7 @@
 #![no_main]
 sphinx_zkvm::entrypoint!(main);
 
-use sphinx_zkvm::syscalls::blake2s_round::syscall_blake2s_quarter_round_2x;
+use sphinx_zkvm::syscalls::blake2s_round::syscall_blake2s_round;
 
 pub fn main() {
     let mut a: [u32; 16] = [
@@ -11,12 +11,5 @@ pub fn main() {
     ];
     let b: [u32; 24] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
 
-    syscall_blake2s_quarter_round_2x(a.as_mut_ptr(), b.as_ptr());
-
-    assert_eq!(a, [
-        0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3,
-        0x515f5af4, 0x301095b, 0xb151a3c2, 0x5e17f96f,
-        0xc561666d, 0xf291605, 0x990c6d13, 0x76fff6f1,
-        0x1e53bf19, 0x6fe4a680, 0x8e33663, 0x97fd885e,
-    ]);
+    syscall_blake2s_round(a.as_mut_ptr(), b.as_ptr());
 }
diff --git a/tests/blake2s-xor-rotate-16/Cargo.lock b/tests/blake2s-xor-rotate-16/Cargo.lock
deleted file mode 100644
index 7ab25f1f3..000000000
--- a/tests/blake2s-xor-rotate-16/Cargo.lock
+++ /dev/null
@@ -1,539 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "anyhow"
-version = "1.0.88"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e1496f8fb1fbf272686b8d37f523dab3e4a7443300055e74cdaa449f3114356"
-
-[[package]]
-name = "base16ct"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
-
-[[package]]
-name = "base64ct"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
-
-[[package]]
-name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "blake2s-xor-rotate-right-test"
-version = "0.1.0"
-dependencies = [
- "sphinx-zkvm",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crypto-bigint"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
-dependencies = [
- "generic-array",
- "rand_core",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "der"
-version = "0.7.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
-dependencies = [
- "const-oid",
- "zeroize",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "const-oid",
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "ecdsa"
-version = "0.16.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
-dependencies = [
- "der",
- "digest",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
-]
-
-[[package]]
-name = "elliptic-curve"
-version = "0.13.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
-dependencies = [
- "base16ct",
- "crypto-bigint",
- "digest",
- "ff",
- "generic-array",
- "group",
- "pkcs8",
- "rand_core",
- "sec1",
- "subtle",
- "tap",
- "zeroize",
-]
-
-[[package]]
-name = "ff"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
-dependencies = [
- "bitvec",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
- "zeroize",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "group"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
-dependencies = [
- "ff",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "hybrid-array"
-version = "0.2.0-rc.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "k256"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "once_cell",
- "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "signature",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
-[[package]]
-name = "libc"
-version = "0.2.158"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
-
-[[package]]
-name = "libm"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
-
-[[package]]
-name = "once_cell"
-version = "1.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rfc6979"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
-dependencies = [
- "hmac",
- "subtle",
-]
-
-[[package]]
-name = "sec1"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
-dependencies = [
- "base16ct",
- "der",
- "generic-array",
- "pkcs8",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "signature"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
-dependencies = [
- "digest",
- "rand_core",
-]
-
-[[package]]
-name = "sphinx-precompiles"
-version = "1.0.0"
-dependencies = [
- "anyhow",
- "bincode",
- "cfg-if",
- "getrandom",
- "hybrid-array",
- "k256",
- "serde",
-]
-
-[[package]]
-name = "sphinx-zkvm"
-version = "1.0.0"
-dependencies = [
- "bincode",
- "cfg-if",
- "getrandom",
- "k256",
- "lazy_static",
- "libm",
- "once_cell",
- "rand",
- "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
- "sphinx-precompiles",
-]
-
-[[package]]
-name = "spki"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
-dependencies = [
- "base64ct",
- "der",
-]
-
-[[package]]
-name = "subtle"
-version = "2.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
-
-[[package]]
-name = "syn"
-version = "2.0.77"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "typenum"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
-
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wyz"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
-
-[[package]]
-name = "zerocopy"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
-dependencies = [
- "byteorder",
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "zeroize"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-xor-rotate-16/Cargo.toml b/tests/blake2s-xor-rotate-16/Cargo.toml
deleted file mode 100644
index 8d49fdcb8..000000000
--- a/tests/blake2s-xor-rotate-16/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[workspace]
-[package]
-name = "blake2s-xor-rotate-right-test"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-xor-rotate-16/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-16/elf/riscv32im-succinct-zkvm-elf
deleted file mode 100755
index f01aafa22980c248238b6d8015bbc6ec5ee35854..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 22924
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
C>XHrs

diff --git a/tests/blake2s-xor-rotate-16/src/main.rs b/tests/blake2s-xor-rotate-16/src/main.rs
deleted file mode 100644
index d9b63a1e0..000000000
--- a/tests/blake2s-xor-rotate-16/src/main.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![no_main]
-sphinx_zkvm::entrypoint!(main);
-
-use sphinx_zkvm::syscalls::blake2s_xor_rotate_16::syscall_blake2s_xor_rotate_16;
-
-pub fn main() {
-    let mut w = [1u32; 64];
-    for _ in 0..10000 {
-        syscall_blake2s_xor_rotate_16(w.as_mut_ptr());
-    }
-}
-
-// summary: cycles=40957, e2e=17694, khz=2.31, proofSize=2.07 MiB
diff --git a/tests/blake2s-xor-rotate-right-12/Cargo.lock b/tests/blake2s-xor-rotate-right-12/Cargo.lock
deleted file mode 100644
index bc27231b9..000000000
--- a/tests/blake2s-xor-rotate-right-12/Cargo.lock
+++ /dev/null
@@ -1,539 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "anyhow"
-version = "1.0.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
-
-[[package]]
-name = "base16ct"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
-
-[[package]]
-name = "base64ct"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
-
-[[package]]
-name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "blake2s-xor-rotate-right-12-test"
-version = "0.1.0"
-dependencies = [
- "sphinx-zkvm",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crypto-bigint"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
-dependencies = [
- "generic-array",
- "rand_core",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "der"
-version = "0.7.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
-dependencies = [
- "const-oid",
- "zeroize",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "const-oid",
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "ecdsa"
-version = "0.16.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
-dependencies = [
- "der",
- "digest",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
-]
-
-[[package]]
-name = "elliptic-curve"
-version = "0.13.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
-dependencies = [
- "base16ct",
- "crypto-bigint",
- "digest",
- "ff",
- "generic-array",
- "group",
- "pkcs8",
- "rand_core",
- "sec1",
- "subtle",
- "tap",
- "zeroize",
-]
-
-[[package]]
-name = "ff"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
-dependencies = [
- "bitvec",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
- "zeroize",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "group"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
-dependencies = [
- "ff",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "hybrid-array"
-version = "0.2.0-rc.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "k256"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "once_cell",
- "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "signature",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
-[[package]]
-name = "libc"
-version = "0.2.158"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
-
-[[package]]
-name = "libm"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
-
-[[package]]
-name = "once_cell"
-version = "1.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rfc6979"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
-dependencies = [
- "hmac",
- "subtle",
-]
-
-[[package]]
-name = "sec1"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
-dependencies = [
- "base16ct",
- "der",
- "generic-array",
- "pkcs8",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "signature"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
-dependencies = [
- "digest",
- "rand_core",
-]
-
-[[package]]
-name = "sphinx-precompiles"
-version = "1.0.0"
-dependencies = [
- "anyhow",
- "bincode",
- "cfg-if",
- "getrandom",
- "hybrid-array",
- "k256",
- "serde",
-]
-
-[[package]]
-name = "sphinx-zkvm"
-version = "1.0.0"
-dependencies = [
- "bincode",
- "cfg-if",
- "getrandom",
- "k256",
- "lazy_static",
- "libm",
- "once_cell",
- "rand",
- "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
- "sphinx-precompiles",
-]
-
-[[package]]
-name = "spki"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
-dependencies = [
- "base64ct",
- "der",
-]
-
-[[package]]
-name = "subtle"
-version = "2.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
-
-[[package]]
-name = "syn"
-version = "2.0.77"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "typenum"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
-
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wyz"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
-
-[[package]]
-name = "zerocopy"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
-dependencies = [
- "byteorder",
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "zeroize"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-xor-rotate-right-12/Cargo.toml b/tests/blake2s-xor-rotate-right-12/Cargo.toml
deleted file mode 100644
index 00618a2be..000000000
--- a/tests/blake2s-xor-rotate-right-12/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[workspace]
-[package]
-name = "blake2s-xor-rotate-right-12-test"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-xor-rotate-right-12/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-right-12/elf/riscv32im-succinct-zkvm-elf
deleted file mode 100755
index 5c00c03793a2dced10e8d0f6df6dd3790f7e8aec..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 25140
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

diff --git a/tests/blake2s-xor-rotate-right-12/src/main.rs b/tests/blake2s-xor-rotate-right-12/src/main.rs
deleted file mode 100644
index 75c6ac8b4..000000000
--- a/tests/blake2s-xor-rotate-right-12/src/main.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![no_main]
-sphinx_zkvm::entrypoint!(main);
-
-use sphinx_zkvm::syscalls::blake2s_xor_rotate_right_12::syscall_blake2s_xor_rotate_right_12;
-
-pub fn main() {
-    let mut a: [u32; 4] = [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
-    let b: [u32; 4] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
-
-    syscall_blake2s_xor_rotate_right_12(a.as_mut_ptr(), b.as_ptr());
-
-    assert_eq!(a, [0x4383a06b, 0x6092062c, 0xad923ed2, 0x823feaf3]);
-}
diff --git a/tests/blake2s-xor-rotate-right-16/Cargo.lock b/tests/blake2s-xor-rotate-right-16/Cargo.lock
deleted file mode 100644
index 733b51ebb..000000000
--- a/tests/blake2s-xor-rotate-right-16/Cargo.lock
+++ /dev/null
@@ -1,539 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "anyhow"
-version = "1.0.87"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10f00e1f6e58a40e807377c75c6a7f97bf9044fab57816f2414e6f5f4499d7b8"
-
-[[package]]
-name = "base16ct"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
-
-[[package]]
-name = "base64ct"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
-
-[[package]]
-name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "blake2s-xor-rotate-right-test"
-version = "0.1.0"
-dependencies = [
- "sphinx-zkvm",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crypto-bigint"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
-dependencies = [
- "generic-array",
- "rand_core",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "der"
-version = "0.7.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
-dependencies = [
- "const-oid",
- "zeroize",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "const-oid",
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "ecdsa"
-version = "0.16.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
-dependencies = [
- "der",
- "digest",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
-]
-
-[[package]]
-name = "elliptic-curve"
-version = "0.13.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
-dependencies = [
- "base16ct",
- "crypto-bigint",
- "digest",
- "ff",
- "generic-array",
- "group",
- "pkcs8",
- "rand_core",
- "sec1",
- "subtle",
- "tap",
- "zeroize",
-]
-
-[[package]]
-name = "ff"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
-dependencies = [
- "bitvec",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
- "zeroize",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "group"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
-dependencies = [
- "ff",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "hybrid-array"
-version = "0.2.0-rc.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "k256"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "once_cell",
- "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "signature",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
-[[package]]
-name = "libc"
-version = "0.2.158"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
-
-[[package]]
-name = "libm"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
-
-[[package]]
-name = "once_cell"
-version = "1.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rfc6979"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
-dependencies = [
- "hmac",
- "subtle",
-]
-
-[[package]]
-name = "sec1"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
-dependencies = [
- "base16ct",
- "der",
- "generic-array",
- "pkcs8",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "signature"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
-dependencies = [
- "digest",
- "rand_core",
-]
-
-[[package]]
-name = "sphinx-precompiles"
-version = "1.0.0"
-dependencies = [
- "anyhow",
- "bincode",
- "cfg-if",
- "getrandom",
- "hybrid-array",
- "k256",
- "serde",
-]
-
-[[package]]
-name = "sphinx-zkvm"
-version = "1.0.0"
-dependencies = [
- "bincode",
- "cfg-if",
- "getrandom",
- "k256",
- "lazy_static",
- "libm",
- "once_cell",
- "rand",
- "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
- "sphinx-precompiles",
-]
-
-[[package]]
-name = "spki"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
-dependencies = [
- "base64ct",
- "der",
-]
-
-[[package]]
-name = "subtle"
-version = "2.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
-
-[[package]]
-name = "syn"
-version = "2.0.77"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "typenum"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
-
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wyz"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
-
-[[package]]
-name = "zerocopy"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
-dependencies = [
- "byteorder",
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "zeroize"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-xor-rotate-right-16/Cargo.toml b/tests/blake2s-xor-rotate-right-16/Cargo.toml
deleted file mode 100644
index 4787ff58f..000000000
--- a/tests/blake2s-xor-rotate-right-16/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[workspace]
-[package]
-name = "blake2s-xor-rotate-right-16-test"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-xor-rotate-right-16/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-right-16/elf/riscv32im-succinct-zkvm-elf
deleted file mode 100755
index 7e5df46dc64f6bce33f7ca736d8674bb49d97f85..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 25140
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

diff --git a/tests/blake2s-xor-rotate-right-16/src/main.rs b/tests/blake2s-xor-rotate-right-16/src/main.rs
deleted file mode 100644
index 5a6a4d658..000000000
--- a/tests/blake2s-xor-rotate-right-16/src/main.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-#![no_main]
-sphinx_zkvm::entrypoint!(main);
-
-use sphinx_zkvm::syscalls::blake2s_xor_rotate_right_16::syscall_blake2s_xor_rotate_right_16;
-
-pub fn main() {
-    let mut a: [u32; 4] = [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
-    let b: [u32; 4] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
-
-    syscall_blake2s_xor_rotate_right_16(a.as_mut_ptr(), b.as_ptr());
-
-    assert_eq!(a, [0xb4383a06, 0xc6092062, 0x2ad923ed, 0x3823feaf]);
-
-    // precompile code
-    //for _ in 0..10000 {
-    //    syscall_blake2s_xor_rotate_right_16(a.as_mut_ptr(), b.as_ptr());
-    //}
-
-    // no-precompile code
-    //for _ in 0..10000 {
-    //    for i in 0..4usize {
-    //        a[i] = (a[i] ^ b[i]).rotate_right(b[4]);
-    //    }
-    //}
-}
-
-
-// summary: cycles=61049, e2e=3532, khz=17.28, proofSize=1.84 MiB (precompile)
-// summary: cycles=1044, e2e=1691, khz=0.62, proofSize=1.84 MiB (no precompile)
\ No newline at end of file
diff --git a/tests/blake2s-xor-rotate-right-7/Cargo.lock b/tests/blake2s-xor-rotate-right-7/Cargo.lock
deleted file mode 100644
index 78535c876..000000000
--- a/tests/blake2s-xor-rotate-right-7/Cargo.lock
+++ /dev/null
@@ -1,539 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "anyhow"
-version = "1.0.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
-
-[[package]]
-name = "base16ct"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
-
-[[package]]
-name = "base64ct"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
-
-[[package]]
-name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "blake2s-xor-rotate-right-7-test"
-version = "0.1.0"
-dependencies = [
- "sphinx-zkvm",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crypto-bigint"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
-dependencies = [
- "generic-array",
- "rand_core",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "der"
-version = "0.7.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
-dependencies = [
- "const-oid",
- "zeroize",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "const-oid",
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "ecdsa"
-version = "0.16.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
-dependencies = [
- "der",
- "digest",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
-]
-
-[[package]]
-name = "elliptic-curve"
-version = "0.13.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
-dependencies = [
- "base16ct",
- "crypto-bigint",
- "digest",
- "ff",
- "generic-array",
- "group",
- "pkcs8",
- "rand_core",
- "sec1",
- "subtle",
- "tap",
- "zeroize",
-]
-
-[[package]]
-name = "ff"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
-dependencies = [
- "bitvec",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
- "zeroize",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "group"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
-dependencies = [
- "ff",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "hybrid-array"
-version = "0.2.0-rc.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "k256"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "once_cell",
- "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "signature",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
-[[package]]
-name = "libc"
-version = "0.2.158"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
-
-[[package]]
-name = "libm"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
-
-[[package]]
-name = "once_cell"
-version = "1.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rfc6979"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
-dependencies = [
- "hmac",
- "subtle",
-]
-
-[[package]]
-name = "sec1"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
-dependencies = [
- "base16ct",
- "der",
- "generic-array",
- "pkcs8",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "signature"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
-dependencies = [
- "digest",
- "rand_core",
-]
-
-[[package]]
-name = "sphinx-precompiles"
-version = "1.0.0"
-dependencies = [
- "anyhow",
- "bincode",
- "cfg-if",
- "getrandom",
- "hybrid-array",
- "k256",
- "serde",
-]
-
-[[package]]
-name = "sphinx-zkvm"
-version = "1.0.0"
-dependencies = [
- "bincode",
- "cfg-if",
- "getrandom",
- "k256",
- "lazy_static",
- "libm",
- "once_cell",
- "rand",
- "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
- "sphinx-precompiles",
-]
-
-[[package]]
-name = "spki"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
-dependencies = [
- "base64ct",
- "der",
-]
-
-[[package]]
-name = "subtle"
-version = "2.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
-
-[[package]]
-name = "syn"
-version = "2.0.77"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "typenum"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
-
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wyz"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
-
-[[package]]
-name = "zerocopy"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
-dependencies = [
- "byteorder",
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "zeroize"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-xor-rotate-right-7/Cargo.toml b/tests/blake2s-xor-rotate-right-7/Cargo.toml
deleted file mode 100644
index a50846983..000000000
--- a/tests/blake2s-xor-rotate-right-7/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[workspace]
-[package]
-name = "blake2s-xor-rotate-right-7-test"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-right-7/elf/riscv32im-succinct-zkvm-elf
deleted file mode 100755
index ffbd8e740a3cf08895ea2de803b385e433165ae8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 25140
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

diff --git a/tests/blake2s-xor-rotate-right-7/src/main.rs b/tests/blake2s-xor-rotate-right-7/src/main.rs
deleted file mode 100644
index 800270450..000000000
--- a/tests/blake2s-xor-rotate-right-7/src/main.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![no_main]
-sphinx_zkvm::entrypoint!(main);
-
-use sphinx_zkvm::syscalls::blake2s_xor_rotate_right_7::syscall_blake2s_xor_rotate_right_7;
-
-pub fn main() {
-    let mut a: [u32; 4] = [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
-    let b: [u32; 4] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
-
-    syscall_blake2s_xor_rotate_right_7(a.as_mut_ptr(), b.as_ptr());
-
-    assert_eq!(a, [0x70740d68, 0x1240c58c, 0xb247da55, 0x47fd5e70]);
-}
diff --git a/tests/blake2s-xor-rotate-right-8/Cargo.lock b/tests/blake2s-xor-rotate-right-8/Cargo.lock
deleted file mode 100644
index 76e896b8b..000000000
--- a/tests/blake2s-xor-rotate-right-8/Cargo.lock
+++ /dev/null
@@ -1,539 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "anyhow"
-version = "1.0.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
-
-[[package]]
-name = "base16ct"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
-
-[[package]]
-name = "base64ct"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
-
-[[package]]
-name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "blake2s-xor-rotate-right-8-test"
-version = "0.1.0"
-dependencies = [
- "sphinx-zkvm",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crypto-bigint"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
-dependencies = [
- "generic-array",
- "rand_core",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "der"
-version = "0.7.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
-dependencies = [
- "const-oid",
- "zeroize",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "const-oid",
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "ecdsa"
-version = "0.16.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
-dependencies = [
- "der",
- "digest",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
-]
-
-[[package]]
-name = "elliptic-curve"
-version = "0.13.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
-dependencies = [
- "base16ct",
- "crypto-bigint",
- "digest",
- "ff",
- "generic-array",
- "group",
- "pkcs8",
- "rand_core",
- "sec1",
- "subtle",
- "tap",
- "zeroize",
-]
-
-[[package]]
-name = "ff"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
-dependencies = [
- "bitvec",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
- "zeroize",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "group"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
-dependencies = [
- "ff",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "hybrid-array"
-version = "0.2.0-rc.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "k256"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "once_cell",
- "sha2 0.10.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "signature",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
-[[package]]
-name = "libc"
-version = "0.2.158"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
-
-[[package]]
-name = "libm"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
-
-[[package]]
-name = "once_cell"
-version = "1.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ea5043e58958ee56f3e15a90aee535795cd7dfd319846288d93c5b57d85cbe"
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rfc6979"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
-dependencies = [
- "hmac",
- "subtle",
-]
-
-[[package]]
-name = "sec1"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
-dependencies = [
- "base16ct",
- "der",
- "generic-array",
- "pkcs8",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.210"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.8"
-source = "git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8#1f224388fdede7cef649bce0d63876d1a9e3f515"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "signature"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
-dependencies = [
- "digest",
- "rand_core",
-]
-
-[[package]]
-name = "sphinx-precompiles"
-version = "1.0.0"
-dependencies = [
- "anyhow",
- "bincode",
- "cfg-if",
- "getrandom",
- "hybrid-array",
- "k256",
- "serde",
-]
-
-[[package]]
-name = "sphinx-zkvm"
-version = "1.0.0"
-dependencies = [
- "bincode",
- "cfg-if",
- "getrandom",
- "k256",
- "lazy_static",
- "libm",
- "once_cell",
- "rand",
- "sha2 0.10.8 (git+https://github.com/sp1-patches/RustCrypto-hashes?branch=patch-v0.10.8)",
- "sphinx-precompiles",
-]
-
-[[package]]
-name = "spki"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
-dependencies = [
- "base64ct",
- "der",
-]
-
-[[package]]
-name = "subtle"
-version = "2.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
-
-[[package]]
-name = "syn"
-version = "2.0.77"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "typenum"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
-
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wyz"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
-
-[[package]]
-name = "zerocopy"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
-dependencies = [
- "byteorder",
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.7.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "zeroize"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/tests/blake2s-xor-rotate-right-8/Cargo.toml b/tests/blake2s-xor-rotate-right-8/Cargo.toml
deleted file mode 100644
index 82899e0ef..000000000
--- a/tests/blake2s-xor-rotate-right-8/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[workspace]
-[package]
-name = "blake2s-xor-rotate-right-8-test"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-sphinx-zkvm = { path = "../../zkvm/entrypoint" }
diff --git a/tests/blake2s-xor-rotate-right-8/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-xor-rotate-right-8/elf/riscv32im-succinct-zkvm-elf
deleted file mode 100755
index a4271c1948c7a60297340f635de16d5b931fcd57..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 25140
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

diff --git a/tests/blake2s-xor-rotate-right-8/src/main.rs b/tests/blake2s-xor-rotate-right-8/src/main.rs
deleted file mode 100644
index 987643abe..000000000
--- a/tests/blake2s-xor-rotate-right-8/src/main.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![no_main]
-sphinx_zkvm::entrypoint!(main);
-
-use sphinx_zkvm::syscalls::blake2s_xor_rotate_right_8::syscall_blake2s_xor_rotate_right_8;
-
-pub fn main() {
-    let mut a: [u32; 4] = [0x6b08e647, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a];
-    let b: [u32; 4] = [0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
-
-    syscall_blake2s_xor_rotate_right_8(a.as_mut_ptr(), b.as_ptr());
-
-    assert_eq!(a, [0x383a06b4, 0x92062c6, 0xd923ed2a, 0x23feaf38]);
-}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_add_2.rs b/zkvm/entrypoint/src/syscalls/blake2s_add_2.rs
deleted file mode 100644
index 01ffd1d5b..000000000
--- a/zkvm/entrypoint/src/syscalls/blake2s_add_2.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#[cfg(target_os = "zkvm")]
-use core::arch::asm;
-
-#[allow(unused_variables)]
-#[no_mangle]
-pub extern "C" fn syscall_blake2s_add_2(left: *mut u32, right: *const u32) {
-    #[cfg(target_os = "zkvm")]
-    unsafe {
-        asm!(
-        "ecall",
-        in("t0") crate::syscalls::BLAKE_2S_ADD_2,
-        in("a0") left,
-        in("a1") right
-        );
-    }
-
-    #[cfg(not(target_os = "zkvm"))]
-    unreachable!()
-}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_add_3.rs b/zkvm/entrypoint/src/syscalls/blake2s_add_3.rs
deleted file mode 100644
index ad6ce95cd..000000000
--- a/zkvm/entrypoint/src/syscalls/blake2s_add_3.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#[cfg(target_os = "zkvm")]
-use core::arch::asm;
-
-#[allow(unused_variables)]
-#[no_mangle]
-pub extern "C" fn syscall_blake2s_add_3(left: *mut u32, right: *const u32) {
-    #[cfg(target_os = "zkvm")]
-    unsafe {
-        asm!(
-        "ecall",
-        in("t0") crate::syscalls::BLAKE_2S_ADD_3,
-        in("a0") left,
-        in("a1") right
-        );
-    }
-
-    #[cfg(not(target_os = "zkvm"))]
-    unreachable!()
-}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_round.rs b/zkvm/entrypoint/src/syscalls/blake2s_round.rs
index 358e9615c..d3f33f801 100644
--- a/zkvm/entrypoint/src/syscalls/blake2s_round.rs
+++ b/zkvm/entrypoint/src/syscalls/blake2s_round.rs
@@ -3,12 +3,12 @@ use core::arch::asm;
 
 #[allow(unused_variables)]
 #[no_mangle]
-pub extern "C" fn syscall_blake2s_quarter_round_2x(left: *mut u32, right: *const u32) {
+pub extern "C" fn syscall_blake2s_round(left: *mut u32, right: *const u32) {
     #[cfg(target_os = "zkvm")]
     unsafe {
         asm!(
         "ecall",
-        in("t0") crate::syscalls::BLAKE_2S_QUARTER_ROUND_2X,
+        in("t0") crate::syscalls::BLAKE_2S_ROUND,
         in("a0") left,
         in("a1") right
         );
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_16.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_16.rs
deleted file mode 100644
index 112feab08..000000000
--- a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_16.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#[cfg(target_os = "zkvm")]
-use core::arch::asm;
-
-#[allow(unused_variables)]
-#[no_mangle]
-pub extern "C" fn syscall_blake2s_xor_rotate_16(w: *mut u32) {
-    #[cfg(target_os = "zkvm")]
-    unsafe {
-        asm!(
-        "ecall",
-        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_16,
-        in("a0") w,
-        in("a1") 0
-        );
-    }
-
-    #[cfg(not(target_os = "zkvm"))]
-    unreachable!()
-}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_12.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_12.rs
deleted file mode 100644
index e74d0ae5c..000000000
--- a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_12.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#[cfg(target_os = "zkvm")]
-use core::arch::asm;
-
-#[allow(unused_variables)]
-#[no_mangle]
-pub extern "C" fn syscall_blake2s_xor_rotate_right_12(left: *mut u32, right: *const u32) {
-    #[cfg(target_os = "zkvm")]
-    unsafe {
-        asm!(
-        "ecall",
-        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_12,
-        in("a0") left,
-        in("a1") right
-        );
-    }
-
-    #[cfg(not(target_os = "zkvm"))]
-    unreachable!()
-}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_16.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_16.rs
deleted file mode 100644
index 4d04d4057..000000000
--- a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_16.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#[cfg(target_os = "zkvm")]
-use core::arch::asm;
-
-#[allow(unused_variables)]
-#[no_mangle]
-pub extern "C" fn syscall_blake2s_xor_rotate_right_16(left: *mut u32, right: *const u32) {
-    #[cfg(target_os = "zkvm")]
-    unsafe {
-        asm!(
-        "ecall",
-        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_16,
-        in("a0") left,
-        in("a1") right
-        );
-    }
-
-    #[cfg(not(target_os = "zkvm"))]
-    unreachable!()
-}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_7.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_7.rs
deleted file mode 100644
index be2aee1fa..000000000
--- a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_7.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#[cfg(target_os = "zkvm")]
-use core::arch::asm;
-
-#[allow(unused_variables)]
-#[no_mangle]
-pub extern "C" fn syscall_blake2s_xor_rotate_right_7(left: *mut u32, right: *const u32) {
-    #[cfg(target_os = "zkvm")]
-    unsafe {
-        asm!(
-        "ecall",
-        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_7,
-        in("a0") left,
-        in("a1") right
-        );
-    }
-
-    #[cfg(not(target_os = "zkvm"))]
-    unreachable!()
-}
diff --git a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_8.rs b/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_8.rs
deleted file mode 100644
index 623f6bb4b..000000000
--- a/zkvm/entrypoint/src/syscalls/blake2s_xor_rotate_right_8.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#[cfg(target_os = "zkvm")]
-use core::arch::asm;
-
-#[allow(unused_variables)]
-#[no_mangle]
-pub extern "C" fn syscall_blake2s_xor_rotate_right_8(left: *mut u32, right: *const u32) {
-    #[cfg(target_os = "zkvm")]
-    unsafe {
-        asm!(
-        "ecall",
-        in("t0") crate::syscalls::BLAKE_2S_XOR_ROTATE_RIGHT_8,
-        in("a0") left,
-        in("a1") right
-        );
-    }
-
-    #[cfg(not(target_os = "zkvm"))]
-    unreachable!()
-}
diff --git a/zkvm/entrypoint/src/syscalls/mod.rs b/zkvm/entrypoint/src/syscalls/mod.rs
index 647e5202a..87a80e070 100644
--- a/zkvm/entrypoint/src/syscalls/mod.rs
+++ b/zkvm/entrypoint/src/syscalls/mod.rs
@@ -13,14 +13,7 @@ mod unconstrained;
 #[cfg(feature = "verify")]
 mod verify;
 
-pub mod blake2s_add_2;
-pub mod blake2s_add_3;
 pub mod blake2s_round;
-pub mod blake2s_xor_rotate_16;
-pub mod blake2s_xor_rotate_right_12;
-pub mod blake2s_xor_rotate_right_16;
-pub mod blake2s_xor_rotate_right_7;
-pub mod blake2s_xor_rotate_right_8;
 
 pub use bls12_381::*;
 pub use bn254::*;
@@ -116,18 +109,5 @@ pub const BLS12381_G1_DOUBLE: u32 = 0x00_00_01_72;
 /// Executes `BLS12381_G1_DECOMPRESS`.
 pub const BLS12381_G1_DECOMPRESS: u32 = 0x00_01_01_F2;
 
-pub const BLAKE_2S_XOR_ROTATE_RIGHT_16: u32 = 0x00_01_01_CC;
-
-pub const BLAKE_2S_XOR_ROTATE_16: u32 = 0x00_30_01_CD;
-
-pub const BLAKE_2S_ADD_2: u32 = 0x00_01_01_CE;
-
-pub const BLAKE_2S_ADD_3: u32 = 0x00_01_01_CF;
-
-pub const BLAKE_2S_XOR_ROTATE_RIGHT_12: u32 = 0x00_01_01_EA;
-
-pub const BLAKE_2S_XOR_ROTATE_RIGHT_8: u32 = 0x00_01_01_EB;
-
-pub const BLAKE_2S_XOR_ROTATE_RIGHT_7: u32 = 0x00_01_01_EC;
-
-pub const BLAKE_2S_QUARTER_ROUND_2X: u32 = 0x00_01_01_ED;
+/// Executes `BLAKE2S_ROUND`.
+pub const BLAKE_2S_ROUND: u32 = 0x00_01_01_ED;

From c97c0435953cda829677b0d3374c29bf411f0a4b Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 23 Sep 2024 14:44:28 +0300
Subject: [PATCH 25/30] chore: Split round syscall implementation to multiple
 source files

---
 core/src/syscall/precompiles/blake2s/air.rs   |  385 ++++++
 .../syscall/precompiles/blake2s/columns.rs    |   39 +
 .../syscall/precompiles/blake2s/execute.rs    |  195 +++
 core/src/syscall/precompiles/blake2s/mod.rs   |  158 ++-
 core/src/syscall/precompiles/blake2s/round.rs | 1111 -----------------
 core/src/syscall/precompiles/blake2s/trace.rs |  368 ++++++
 6 files changed, 1143 insertions(+), 1113 deletions(-)
 create mode 100644 core/src/syscall/precompiles/blake2s/air.rs
 create mode 100644 core/src/syscall/precompiles/blake2s/columns.rs
 create mode 100644 core/src/syscall/precompiles/blake2s/execute.rs
 delete mode 100644 core/src/syscall/precompiles/blake2s/round.rs
 create mode 100644 core/src/syscall/precompiles/blake2s/trace.rs

diff --git a/core/src/syscall/precompiles/blake2s/air.rs b/core/src/syscall/precompiles/blake2s/air.rs
new file mode 100644
index 000000000..0a0e57759
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/air.rs
@@ -0,0 +1,385 @@
+use crate::memory::MemoryCols;
+use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation};
+use crate::runtime::SyscallCode;
+use crate::stark::SphinxAirBuilder;
+use crate::syscall::precompiles::blake2s::columns::Blake2sRoundCols;
+use crate::syscall::precompiles::blake2s::{Blake2sRoundChip, R_1, R_2, R_3, R_4};
+use core::borrow::Borrow;
+use p3_air::{Air, AirBuilder, BaseAir};
+use p3_field::{AbstractField, PrimeField32};
+use p3_matrix::Matrix;
+use std::mem::size_of;
+
+impl<T: PrimeField32> BaseAir<T> for Blake2sRoundChip {
+    fn width(&self) -> usize {
+        size_of::<Blake2sRoundCols<u8>>()
+    }
+}
+
+impl<AB: SphinxAirBuilder> Air<AB> for Blake2sRoundChip
+where
+    AB::F: PrimeField32,
+{
+    fn eval(&self, builder: &mut AB) {
+        let main = builder.main();
+        let local = main.row_slice(0);
+        let next = main.row_slice(1);
+        let local: &Blake2sRoundCols<AB::Var> = (*local).borrow();
+        let next: &Blake2sRoundCols<AB::Var> = (*next).borrow();
+
+        // Constrain the incrementing nonce.
+        builder.when_first_row().assert_zero(local.nonce);
+        builder
+            .when_transition()
+            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
+
+        for i in 0..16usize {
+            // Eval a
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
+                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.a[i],
+                local.is_real,
+            );
+
+            // Eval b
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
+        }
+
+        // zeroes
+        for i in 16..24usize {
+            // Eval b
+            builder.eval_memory_access(
+                local.shard,
+                local.channel,
+                local.clk,
+                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
+                &local.b[i],
+                local.is_real,
+            );
+        }
+
+        let v1_shuffle_lookup = vec![1, 2, 3, 0];
+        let v2_shuffle_lookup = vec![2, 3, 0, 1];
+        let v3_shuffle_lookup = vec![3, 0, 1, 2];
+
+        for i in 0..4usize {
+            // 1x
+
+            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+            Add4Operation::<AB::F>::eval(
+                builder,
+                *local.a[i].prev_value(),     // v0
+                *local.a[i + 4].prev_value(), // v1
+                *local.b[i].value(),          // m1
+                *local.b[i + 20].value(),     // zero1
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i],
+            );
+
+            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i + 12].prev_value(),
+                local.add[i].value,
+                local.xor[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i].value,
+                R_1 as usize,
+                local.rotate_right[i],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // v[2] = v[2].wrapping_add(v[3]);
+            Add4Operation::<AB::F>::eval(
+                builder,
+                *local.a[i + 8].prev_value(), // v2
+                local.rotate_right[i].value,  // v3 from previous operation
+                *local.b[i + 16].value(),     // zero1
+                *local.b[i + 20].value(),     // zero2
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 4],
+            );
+
+            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                *local.a[i + 4].prev_value(),
+                local.add[i + 4].value,
+                local.xor[i + 4],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 4].value,
+                R_2 as usize,
+                local.rotate_right[i + 4],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // 2x
+            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+            Add4Operation::<AB::F>::eval(
+                builder,
+                local.add[i].value,              // v0 after 1x
+                local.rotate_right[i + 4].value, // v1 after 1x
+                *local.b[i + 4].value(),         // m2
+                *local.b[i + 16].value(),        // zero1
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 8],
+            );
+
+            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                local.rotate_right[i].value, // v3 after 1x
+                local.add[i + 8].value,      // v0 after 1x
+                local.xor[i + 8],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 8].value,
+                R_3 as usize,
+                local.rotate_right[i + 8],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // v[2] = v[2].wrapping_add(v[3]);
+            Add4Operation::<AB::F>::eval(
+                builder,
+                local.add[i + 4].value,          // v2 after 1x
+                local.rotate_right[i + 8].value, // v3 after previous operation
+                *local.b[i + 16].value(),        // zero1
+                *local.b[i + 20].value(),        // zero2
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 12],
+            );
+
+            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                local.rotate_right[i + 4].value, // v1 after 1x
+                local.add[i + 12].value,         // v2 after previous operation
+                local.xor[i + 12],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 12].value,
+                R_4 as usize,
+                local.rotate_right[i + 12],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+        }
+
+        self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
+
+        for i in 0..4usize {
+            // 3x
+            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+            Add4Operation::<AB::F>::eval(
+                builder,
+                local.add[i + 8].value, // v0 after 2x
+                local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
+                *local.b[i + 8].value(), // m3
+                *local.b[i + 16].value(), // zero1
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 16],
+            );
+
+            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x
+                local.add[i + 16].value,                            // v0 after previous operation
+                local.xor[i + 16],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 16].value,
+                R_1 as usize,
+                local.rotate_right[i + 16],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // v[2] = v[2].wrapping_add(v[3]);
+            Add4Operation::<AB::F>::eval(
+                builder,
+                local.add[v2_shuffle_lookup[i] + 12].value, // v2 after 2x
+                local.rotate_right[i + 16].value,           // v3 after previous operation
+                *local.b[i + 16].value(),                   // zero1
+                *local.b[i + 20].value(),                   // zero2
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 20],
+            );
+
+            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
+                local.add[i + 20].value,                             // v2 after previous operation
+                local.xor[i + 20],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 20].value,
+                R_2 as usize,
+                local.rotate_right[i + 20],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // 4x
+            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+            Add4Operation::<AB::F>::eval(
+                builder,
+                local.add[i + 16].value,          // v0 after 3x
+                local.rotate_right[i + 20].value, // v1 after 3x
+                *local.b[i + 12].value(),         // m4
+                *local.b[i + 16].value(),         // zero1
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 24],
+            );
+
+            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                local.rotate_right[i + 16].value, // v3 after 3x
+                local.add[i + 24].value,          // v0 after previous operation
+                local.xor[i + 24],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 24].value,
+                R_3 as usize,
+                local.rotate_right[i + 24],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // v[2] = v[2].wrapping_add(v[3]);
+            Add4Operation::<AB::F>::eval(
+                builder,
+                local.add[i + 20].value,          // v2 after 3x
+                local.rotate_right[i + 24].value, // v3 after previous operation
+                *local.b[i + 16].value(),         // zero1
+                *local.b[i + 20].value(),         // zero2
+                local.shard,
+                local.channel,
+                local.is_real,
+                local.add[i + 28],
+            );
+
+            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+            // Eval XOR
+            XorOperation::<AB::F>::eval(
+                builder,
+                local.rotate_right[i + 20].value, // v1 after 3x
+                local.add[i + 28].value,          // v2 after previous operation
+                local.xor[i + 28],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+
+            // Eval RotateRight
+            FixedRotateRightOperation::<AB::F>::eval(
+                builder,
+                local.xor[i + 28].value,
+                R_4 as usize,
+                local.rotate_right[i + 28],
+                local.shard,
+                &local.channel,
+                local.is_real,
+            );
+        }
+
+        builder.receive_syscall(
+            local.shard,
+            local.channel,
+            local.clk,
+            local.nonce,
+            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_ROUND.syscall_id()),
+            local.a_ptr,
+            local.b_ptr,
+            local.is_real,
+        )
+    }
+}
diff --git a/core/src/syscall/precompiles/blake2s/columns.rs b/core/src/syscall/precompiles/blake2s/columns.rs
new file mode 100644
index 000000000..a684fd9f0
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/columns.rs
@@ -0,0 +1,39 @@
+use crate::memory::{MemoryReadCols, MemoryWriteCols};
+use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation};
+use sphinx_derive::AlignedBorrow;
+
+#[derive(Debug, Clone, AlignedBorrow)]
+#[repr(C)]
+pub struct Blake2sRoundCols<T> {
+    /// Inputs.
+    pub clk: T,
+    pub shard: T,
+    pub channel: T,
+    pub nonce: T,
+    pub is_real: T,
+
+    pub a_ptr: T,
+    pub b_ptr: T,
+
+    pub shuffled_indices: [T; 16],
+
+    /// Memory layout:
+    /// a: v0[0] || v0[1] || v0[2] || v0[3] ||
+    ///    v1[0] || v1[1] || v1[2] || v1[3] ||
+    ///    v2[0] || v2[1] || v2[2] || v2[3] ||
+    ///    v3[0] || v3[1] || v3[2] || v3[3] ||
+    ///
+    /// b: m0[0] || m0[1] || m0[2] || m0[3] ||
+    ///    m1[0] || m1[1] || m1[2] || m1[3] ||
+    ///    m2[0] || m2[1] || m2[2] || m2[3] ||
+    ///    m3[0] || m3[1] || m3[2] || m3[3] ||
+    ///    0 || 0 || 0 || 0 ||
+    ///    0 || 0 || 0 || 0 ||
+    ///
+    pub a: [MemoryWriteCols<T>; 16],
+    pub b: [MemoryReadCols<T>; 24],
+
+    pub add: [Add4Operation<T>; 32],
+    pub xor: [XorOperation<T>; 32],
+    pub rotate_right: [FixedRotateRightOperation<T>; 32],
+}
diff --git a/core/src/syscall/precompiles/blake2s/execute.rs b/core/src/syscall/precompiles/blake2s/execute.rs
new file mode 100644
index 000000000..06f415bf7
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/execute.rs
@@ -0,0 +1,195 @@
+use crate::runtime::{Syscall, SyscallContext};
+use crate::syscall::precompiles::blake2s::{
+    Blake2sRoundChip, Blake2sRoundEvent, R_1, R_2, R_3, R_4,
+};
+
+impl Syscall for Blake2sRoundChip {
+    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
+        let clk_init = ctx.clk;
+        let shard = ctx.current_shard();
+        let lookup_id = ctx.syscall_lookup_id;
+        let channel = ctx.current_channel();
+
+        let a_ptr = arg1;
+        let b_ptr = arg2;
+
+        let mut a = ctx.slice_unsafe(a_ptr, 16);
+        let mut a_clone = a.clone();
+
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 24);
+
+        // 1x (m1, R1, R2)
+        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m1)
+        for ((v0, v1), m) in a[0..4]
+            .iter_mut()
+            .zip(a_clone[4..8].iter())
+            .zip(b[0..4].iter())
+        {
+            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
+        }
+        a_clone = a.clone();
+
+        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
+            *v3 = (*v3 ^ *v0).rotate_right(R_1);
+        }
+        a_clone = a.clone();
+
+        // v[2] = v[2].wrapping_add(v[3]);
+        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
+            *v2 = (*v2).wrapping_add(*v3);
+        }
+        a_clone = a.clone();
+
+        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
+            *v1 = (*v1 ^ *v2).rotate_right(R_2);
+        }
+
+        // 2x (m2, R3, R4)
+        let mut a = a.clone(); // a after 1x quarter_round
+        let mut a_clone = a.clone();
+
+        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
+        for ((v0, v1), m) in a[0..4]
+            .iter_mut()
+            .zip(a_clone[4..8].iter())
+            .zip(b[4..8].iter())
+        {
+            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
+        }
+        a_clone = a.clone();
+
+        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
+            *v3 = (*v3 ^ *v0).rotate_right(R_3);
+        }
+        a_clone = a.clone();
+
+        // v[2] = v[2].wrapping_add(v[3]);
+        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
+            *v2 = (*v2).wrapping_add(*v3);
+        }
+        a_clone = a.clone();
+
+        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
+            *v1 = (*v1 ^ *v2).rotate_right(R_4);
+        }
+
+        // shuffle
+        // v[1]
+        a[4..8].swap(0, 3);
+        a[4..8].swap(0, 1);
+        a[4..8].swap(1, 2);
+
+        // v[2]
+        a[8..12].swap(0, 2);
+        a[8..12].swap(1, 3);
+
+        // v[3]
+        a[12..16].swap(2, 3);
+        a[12..16].swap(1, 2);
+        a[12..16].swap(0, 1);
+
+        let mut a = a.clone(); // a after 2x quarter_round
+        let mut a_clone = a.clone();
+
+        // 3x (m3, R1, R2)
+        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m3)
+        for ((v0, v1), m) in a[0..4]
+            .iter_mut()
+            .zip(a_clone[4..8].iter())
+            .zip(b[8..12].iter())
+        {
+            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
+        }
+        a_clone = a.clone();
+
+        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
+            *v3 = (*v3 ^ *v0).rotate_right(R_1);
+        }
+        a_clone = a.clone();
+
+        // v[2] = v[2].wrapping_add(v[3]);
+        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
+            *v2 = (*v2).wrapping_add(*v3);
+        }
+        a_clone = a.clone();
+
+        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
+            *v1 = (*v1 ^ *v2).rotate_right(R_2);
+        }
+
+        // 4x (m4, R3, R4)
+        let mut a = a.clone(); // a after 3x quarter_round
+        let mut a_clone = a.clone();
+
+        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
+        for ((v0, v1), m) in a[0..4]
+            .iter_mut()
+            .zip(a_clone[4..8].iter())
+            .zip(b[12..16].iter())
+        {
+            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
+        }
+        a_clone = a.clone();
+
+        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
+            *v3 = (*v3 ^ *v0).rotate_right(R_3);
+        }
+        a_clone = a.clone();
+
+        // v[2] = v[2].wrapping_add(v[3]);
+        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
+            *v2 = (*v2).wrapping_add(*v3);
+        }
+        a_clone = a.clone();
+
+        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
+            *v1 = (*v1 ^ *v2).rotate_right(R_4);
+        }
+
+        // unshuffle
+        // v[1]
+        a[4..8].swap(2, 3);
+        a[4..8].swap(1, 2);
+        a[4..8].swap(0, 1);
+
+        // v[2]
+        a[8..12].swap(0, 2);
+        a[8..12].swap(1, 3);
+
+        // v[3]
+        a[12..16].swap(0, 3);
+        a[12..16].swap(0, 1);
+        a[12..16].swap(1, 2);
+
+        ctx.clk += 1;
+        // Write rotate_right to a_ptr.
+        let a_reads_writes = ctx.mw_slice(a_ptr, a.as_slice());
+
+        ctx.record_mut()
+            .blake2s_round_events
+            .push(Blake2sRoundEvent {
+                lookup_id,
+                clk: clk_init,
+                shard,
+                channel,
+                a_ptr,
+                b_ptr,
+                a_reads_writes,
+                b_reads,
+            });
+
+        None
+    }
+
+    fn num_extra_cycles(&self) -> u32 {
+        1
+    }
+}
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index a9229b40b..1d7cd20c2 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -1,5 +1,73 @@
-mod round;
-pub use round::*;
+mod air;
+mod columns;
+mod execute;
+mod trace;
+
+pub use columns::*;
+
+use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
+use crate::stark::SphinxAirBuilder;
+use p3_air::AirBuilder;
+use p3_field::AbstractField;
+use serde::Deserialize;
+use serde::Serialize;
+
+/// Implements the single round function of Blake2s hashing algorithm.
+/// The correspondent syscall expects two arguments, where the first argument is 4 arrays, each
+/// consists from 4 u32 words one by one and the second is 4 arrays properly constructed from the
+/// message of the Blake2s block:
+///
+///  let m1 = $vec::gather(m, s[0], s[2], s[4], s[6]).from_le();
+///  let m2 = $vec::gather(m, s[1], s[3], s[5], s[7]).from_le();
+///  let m3 = $vec::gather(m, s[8], s[10], s[12], s[14]).from_le();
+///  let m4 = $vec::gather(m, s[9], s[11], s[13], s[15]).from_le();
+///
+/// where s is a SIGMA constant (https://www.rfc-editor.org/rfc/rfc7693.txt).
+
+#[derive(Default)]
+pub struct Blake2sRoundChip;
+
+impl Blake2sRoundChip {
+    pub fn new() -> Self {
+        Blake2sRoundChip
+    }
+    pub fn constrain_shuffled_indices<AB: SphinxAirBuilder>(
+        &self,
+        builder: &mut AB,
+        indices: &[AB::Var],
+        is_real: AB::Var,
+    ) {
+        for index in 0..4 {
+            builder
+                .when(is_real)
+                .assert_eq(indices[index], AB::F::from_canonical_usize(0));
+        }
+        for index in 4..indices.len() {
+            builder
+                .when(is_real)
+                .assert_eq(indices[index], AB::F::from_canonical_usize(1));
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Blake2sRoundEvent {
+    pub lookup_id: usize,
+    pub clk: u32,
+    pub shard: u32,
+    pub channel: u32,
+    pub a_ptr: u32,
+    pub b_ptr: u32,
+
+    pub a_reads_writes: Vec<MemoryWriteRecord>,
+    pub b_reads: Vec<MemoryReadRecord>,
+}
+
+/// Rotation constants
+pub const R_1: u32 = 16;
+pub const R_2: u32 = 12;
+pub const R_3: u32 = 8;
+pub const R_4: u32 = 7;
 
 fn xor_u32x4(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
     [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]]
@@ -106,7 +174,93 @@ pub fn blake2s_round(v: &mut [u32], m: &[u32]) {
 
 #[cfg(test)]
 mod tests {
+    use crate::runtime::{Instruction, Opcode, SyscallCode};
+    use crate::syscall::precompiles::blake2s::blake2s_round;
     use crate::syscall::precompiles::blake2s::{quarter_round, round, shuffle, unshuffle};
+    use crate::utils::tests::BLAKE2S_ROUND_ELF;
+    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
+    use crate::Program;
+    use rand::Rng;
+
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 16], b: [u32; 24]) -> Program {
+        let mut instructions = vec![];
+        // memory write a
+        for (index, word) in a.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                a_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // memory write b
+        for (index, word) in b.into_iter().enumerate() {
+            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
+            instructions.push(Instruction::new(
+                Opcode::ADD,
+                30,
+                0,
+                b_ptr + (index * 4) as u32,
+                false,
+                true,
+            ));
+            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
+        }
+
+        // Syscall invocation
+        instructions.push(Instruction::new(
+            Opcode::ADD,
+            5,
+            0,
+            SyscallCode::BLAKE_2S_ROUND as u32,
+            false,
+            true,
+        ));
+        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
+        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
+        Program::new(instructions, 0, 0)
+    }
+
+    #[test]
+    fn test_blake2s_round_precompile() {
+        setup_logger();
+
+        let a_ptr = 100100100;
+        let b_ptr = 200200200;
+
+        let a = rand::thread_rng().gen::<[u32; 16]>();
+        let mut a_clone = a.clone();
+        let mut b = rand::thread_rng().gen::<[u32; 24]>();
+        for item in b[0..24].iter_mut() {
+            *item = 0;
+        }
+
+        blake2s_round(&mut a_clone, &b);
+
+        let program = risc_v_program(a_ptr, b_ptr, a, b);
+
+        let (_, memory) = run_test_with_memory_inspection(program);
+        let mut result = vec![];
+        // result is 4 words, written to a_ptr
+        for i in 0..16 {
+            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
+        }
+
+        assert_eq!(result, a_clone.to_vec());
+    }
+
+    #[test]
+    fn test_blake2s_round_program() {
+        setup_logger();
+        let program = Program::from(BLAKE2S_ROUND_ELF);
+        run_test(program).unwrap();
+    }
 
     #[test]
     fn test_blake2s_round_function() {
diff --git a/core/src/syscall/precompiles/blake2s/round.rs b/core/src/syscall/precompiles/blake2s/round.rs
deleted file mode 100644
index 2661514cc..000000000
--- a/core/src/syscall/precompiles/blake2s/round.rs
+++ /dev/null
@@ -1,1111 +0,0 @@
-use crate::bytes::event::ByteRecord;
-use crate::memory::{MemoryCols, MemoryReadCols, MemoryWriteCols};
-use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation};
-use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
-use crate::stark::SphinxAirBuilder;
-use crate::utils::pad_rows;
-use crate::{
-    air::{EventLens, MachineAir, WithEvents},
-    runtime::{ExecutionRecord, Program, Syscall, SyscallCode, SyscallContext},
-};
-use core::borrow::{Borrow, BorrowMut};
-use p3_air::{Air, AirBuilder, BaseAir};
-use p3_field::{AbstractField, PrimeField32};
-use p3_matrix::dense::RowMajorMatrix;
-use p3_matrix::Matrix;
-use serde::Deserialize;
-use serde::Serialize;
-use sphinx_derive::AlignedBorrow;
-use std::mem::size_of;
-
-const R_1: u32 = 16;
-const R_2: u32 = 12;
-const R_3: u32 = 8;
-const R_4: u32 = 7;
-
-#[derive(Default)]
-pub struct Blake2sRoundChip;
-
-impl Blake2sRoundChip {
-    pub fn new() -> Self {
-        Blake2sRoundChip
-    }
-    pub fn constrain_shuffled_indices<AB: SphinxAirBuilder>(
-        &self,
-        builder: &mut AB,
-        indices: &[AB::Var],
-        is_real: AB::Var,
-    ) {
-        for index in 0..4 {
-            builder
-                .when(is_real)
-                .assert_eq(indices[index], AB::F::from_canonical_usize(0));
-        }
-        for index in 4..indices.len() {
-            builder
-                .when(is_real)
-                .assert_eq(indices[index], AB::F::from_canonical_usize(1));
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Blake2sRoundEvent {
-    pub lookup_id: usize,
-    pub clk: u32,
-    pub shard: u32,
-    pub channel: u32,
-    pub a_ptr: u32,
-    pub b_ptr: u32,
-
-    pub a_reads_writes: Vec<MemoryWriteRecord>,
-    pub b_reads: Vec<MemoryReadRecord>,
-}
-
-impl Syscall for Blake2sRoundChip {
-    fn execute(&self, ctx: &mut SyscallContext<'_, '_>, arg1: u32, arg2: u32) -> Option<u32> {
-        let clk_init = ctx.clk;
-        let shard = ctx.current_shard();
-        let lookup_id = ctx.syscall_lookup_id;
-        let channel = ctx.current_channel();
-
-        let a_ptr = arg1;
-        let b_ptr = arg2;
-
-        // a: v[0] || v[1] || v[2] || v[3] || v[4] || v[5] || v[6] || v[7] || v[8] || v[9] || v[10] || v[11] || v[12] || v[13] || v[14] || v[15] ||
-        let mut a = ctx.slice_unsafe(a_ptr, 16);
-        let mut a_clone = a.clone();
-
-        // b: m1[0] || m1[1] || m1[2] || m1[3] || || m2[0] || m2[1] || m2[2] || m2[3] ||
-        //    m3[0] || m3[1] || m3[2] || m3[3] || m4[0] || m4[1] || m4[2] || mr[3] ||
-        //    0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
-        let (b_reads, b) = ctx.mr_slice(b_ptr, 24);
-        assert_eq!(b[16], 0u32);
-        assert_eq!(b[17], 0u32);
-        assert_eq!(b[18], 0u32);
-        assert_eq!(b[19], 0u32);
-        assert_eq!(b[20], 0u32);
-        assert_eq!(b[21], 0u32);
-        assert_eq!(b[22], 0u32);
-        assert_eq!(b[23], 0u32);
-
-        // 1x (m1, R1, R2)
-        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m1)
-        for ((v0, v1), m) in a[0..4]
-            .iter_mut()
-            .zip(a_clone[4..8].iter())
-            .zip(b[0..4].iter())
-        {
-            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
-        }
-        a_clone = a.clone();
-
-        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
-            *v3 = (*v3 ^ *v0).rotate_right(R_1);
-        }
-        a_clone = a.clone();
-
-        // v[2] = v[2].wrapping_add(v[3]);
-        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
-            *v2 = (*v2).wrapping_add(*v3);
-        }
-        a_clone = a.clone();
-
-        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
-            *v1 = (*v1 ^ *v2).rotate_right(R_2);
-        }
-
-        // 2x (m2, R3, R4)
-        let mut a = a.clone(); // a after 1x quarter_round
-        let mut a_clone = a.clone();
-
-        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
-        for ((v0, v1), m) in a[0..4]
-            .iter_mut()
-            .zip(a_clone[4..8].iter())
-            .zip(b[4..8].iter())
-        {
-            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
-        }
-        a_clone = a.clone();
-
-        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
-            *v3 = (*v3 ^ *v0).rotate_right(R_3);
-        }
-        a_clone = a.clone();
-
-        // v[2] = v[2].wrapping_add(v[3]);
-        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
-            *v2 = (*v2).wrapping_add(*v3);
-        }
-        a_clone = a.clone();
-
-        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
-            *v1 = (*v1 ^ *v2).rotate_right(R_4);
-        }
-
-        // shuffle
-        // v[1]
-        a[4..8].swap(0, 3);
-        a[4..8].swap(0, 1);
-        a[4..8].swap(1, 2);
-
-        // v[2]
-        a[8..12].swap(0, 2);
-        a[8..12].swap(1, 3);
-
-        // v[3]
-        a[12..16].swap(2, 3);
-        a[12..16].swap(1, 2);
-        a[12..16].swap(0, 1);
-
-        let mut a = a.clone(); // a after 2x quarter_round
-        let mut a_clone = a.clone();
-
-        // 3x (m3, R1, R2)
-        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m3)
-        for ((v0, v1), m) in a[0..4]
-            .iter_mut()
-            .zip(a_clone[4..8].iter())
-            .zip(b[8..12].iter())
-        {
-            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
-        }
-        a_clone = a.clone();
-
-        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
-            *v3 = (*v3 ^ *v0).rotate_right(R_1);
-        }
-        a_clone = a.clone();
-
-        // v[2] = v[2].wrapping_add(v[3]);
-        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
-            *v2 = (*v2).wrapping_add(*v3);
-        }
-        a_clone = a.clone();
-
-        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
-            *v1 = (*v1 ^ *v2).rotate_right(R_2);
-        }
-
-        // 4x (m4, R3, R4)
-        let mut a = a.clone(); // a after 3x quarter_round
-        let mut a_clone = a.clone();
-
-        // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
-        for ((v0, v1), m) in a[0..4]
-            .iter_mut()
-            .zip(a_clone[4..8].iter())
-            .zip(b[12..16].iter())
-        {
-            *v0 = (*v0).wrapping_add(*v1).wrapping_add(*m);
-        }
-        a_clone = a.clone();
-
-        // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-        for (v3, v0) in a[12..16].iter_mut().zip(a_clone[0..4].iter()) {
-            *v3 = (*v3 ^ *v0).rotate_right(R_3);
-        }
-        a_clone = a.clone();
-
-        // v[2] = v[2].wrapping_add(v[3]);
-        for (v2, v3) in a[8..12].iter_mut().zip(a_clone[12..16].iter()) {
-            *v2 = (*v2).wrapping_add(*v3);
-        }
-        a_clone = a.clone();
-
-        // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-        for (v1, v2) in a[4..8].iter_mut().zip(a_clone[8..12].iter()) {
-            *v1 = (*v1 ^ *v2).rotate_right(R_4);
-        }
-
-        // unshuffle
-        // v[1]
-        a[4..8].swap(2, 3);
-        a[4..8].swap(1, 2);
-        a[4..8].swap(0, 1);
-
-        // v[2]
-        a[8..12].swap(0, 2);
-        a[8..12].swap(1, 3);
-
-        // v[3]
-        a[12..16].swap(0, 3);
-        a[12..16].swap(0, 1);
-        a[12..16].swap(1, 2);
-
-        ctx.clk += 1;
-        // Write rotate_right to a_ptr.
-        let a_reads_writes = ctx.mw_slice(a_ptr, a.as_slice());
-
-        ctx.record_mut()
-            .blake2s_round_events
-            .push(Blake2sRoundEvent {
-                lookup_id,
-                clk: clk_init,
-                shard,
-                channel,
-                a_ptr,
-                b_ptr,
-                a_reads_writes,
-                b_reads,
-            });
-
-        None
-    }
-
-    fn num_extra_cycles(&self) -> u32 {
-        1
-    }
-}
-
-#[derive(Debug, Clone, AlignedBorrow)]
-#[repr(C)]
-struct Blake2sRoundCols<T> {
-    pub clk: T,
-    pub shard: T,
-    pub channel: T,
-    pub nonce: T,
-    pub is_real: T,
-
-    pub a_ptr: T,
-    pub b_ptr: T,
-
-    pub shuffled_indices: [T; 16],
-
-    pub a: [MemoryWriteCols<T>; 16],
-    pub b: [MemoryReadCols<T>; 24],
-
-    pub add: [Add4Operation<T>; 32],
-    pub xor: [XorOperation<T>; 32],
-    pub rotate_right: [FixedRotateRightOperation<T>; 32],
-}
-
-impl<T: PrimeField32> BaseAir<T> for Blake2sRoundChip {
-    fn width(&self) -> usize {
-        size_of::<Blake2sRoundCols<u8>>()
-    }
-}
-
-impl<'a> WithEvents<'a> for Blake2sRoundChip {
-    type Events = &'a [Blake2sRoundEvent];
-}
-
-impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
-    type Record = ExecutionRecord;
-    type Program = Program;
-
-    fn name(&self) -> String {
-        "Blake2sRoundChip".to_string()
-    }
-
-    fn generate_trace<EL: EventLens<Self>>(
-        &self,
-        input: &EL,
-        output: &mut Self::Record,
-    ) -> RowMajorMatrix<F> {
-        let mut rows = vec![];
-        let width = <Blake2sRoundChip as BaseAir<F>>::width(self);
-        let mut new_byte_lookup_events = Vec::new();
-        for event in input.events() {
-            let shard = event.shard;
-            let mut row = vec![F::zero(); width];
-            let cols: &mut Blake2sRoundCols<F> = row.as_mut_slice().borrow_mut();
-
-            cols.clk = F::from_canonical_u32(event.clk);
-            cols.is_real = F::one();
-            cols.shard = F::from_canonical_u32(event.shard);
-            cols.channel = F::from_canonical_u32(event.channel);
-            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
-            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
-
-            // populate all v, m
-            for i in 0..16usize {
-                cols.a[i].populate(
-                    event.channel,
-                    event.a_reads_writes[i],
-                    &mut new_byte_lookup_events,
-                );
-                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
-            }
-
-            // populate zeroes
-            for i in 16..24usize {
-                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
-            }
-
-            let mut v0_outer = vec![0u32; 4];
-            let mut v1_outer = vec![0u32; 4];
-            let mut v2_outer = vec![0u32; 4];
-            let mut v3_outer = vec![0u32; 4];
-
-            // 1x (m1, R1, R2)
-            for i in 0..4usize {
-                let v0 = event.a_reads_writes[i].prev_value;
-                let v1 = event.a_reads_writes[i + 4].prev_value;
-                let v2 = event.a_reads_writes[i + 8].prev_value;
-                let v3 = event.a_reads_writes[i + 12].prev_value;
-                let m1 = event.b_reads[i].value;
-                let zero1 = event.b_reads[i + 16].value;
-                let zero2 = event.b_reads[i + 20].value;
-                assert_eq!(zero1, 0);
-                assert_eq!(zero2, 0);
-
-                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-                let v0_new = cols.add[i].populate(output, shard, event.channel, v0, v1, m1, zero1);
-                assert_eq!(v0 + v1 + m1 + zero1, v0_new);
-
-                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-                let temp = cols.xor[i].populate(output, shard, event.channel, v3, v0_new);
-                let v3_new =
-                    cols.rotate_right[i].populate(output, shard, event.channel, temp, R_1 as usize);
-                assert_eq!((v3 ^ v0_new).rotate_right(R_1), v3_new);
-
-                // v[2] = v[2].wrapping_add(v[3]);
-                let v2_new = cols.add[i + 4].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    v2,
-                    v3_new,
-                    zero1,
-                    zero2,
-                );
-                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
-
-                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-                let temp = cols.xor[i + 4].populate(output, shard, event.channel, v1, v2_new);
-                let v1_new = cols.rotate_right[i + 4].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    temp,
-                    R_2 as usize,
-                );
-                assert_eq!((v1 ^ v2_new).rotate_right(R_2), v1_new);
-
-                v0_outer[i] = v0_new;
-                v1_outer[i] = v1_new;
-                v2_outer[i] = v2_new;
-                v3_outer[i] = v3_new;
-            }
-
-            // 2x (m2, R3, R4)
-            for i in 0..4usize {
-                let v0 = v0_outer[i];
-                let v1 = v1_outer[i];
-                let v2 = v2_outer[i];
-                let v3 = v3_outer[i];
-                let m2 = event.b_reads[i + 4].value;
-                let zero1 = event.b_reads[i + 16].value;
-                let zero2 = event.b_reads[i + 20].value;
-                assert_eq!(zero1, 0);
-                assert_eq!(zero2, 0);
-
-                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
-                let v0_new =
-                    cols.add[i + 8].populate(output, shard, event.channel, v0, v1, m2, zero1);
-                assert_eq!(v0 + v1 + m2 + zero1, v0_new);
-
-                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
-                //cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
-                let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0_new);
-                //let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
-                let v3_new = cols.rotate_right[i + 8].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    temp,
-                    R_3 as usize,
-                );
-                assert_eq!((v3 ^ v0_new).rotate_right(R_3), v3_new);
-
-                // v[2] = v[2].wrapping_add(v[3]);
-                //cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
-                //let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
-                let v2_new = cols.add[i + 4 + 8].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    v2,
-                    v3_new,
-                    zero1,
-                    zero2,
-                );
-                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
-
-                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
-                //cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
-                let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2_new);
-                //let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
-                let v1_new = cols.rotate_right[i + 4 + 8].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    temp,
-                    R_4 as usize,
-                );
-                assert_eq!((v1 ^ v2_new).rotate_right(R_4), v1_new);
-
-                v0_outer[i] = v0_new;
-                v1_outer[i] = v1_new;
-                v2_outer[i] = v2_new;
-                v3_outer[i] = v3_new;
-            }
-
-            // shuffle
-            // v[1]
-            v1_outer.swap(0, 3);
-            v1_outer.swap(0, 1);
-            v1_outer.swap(1, 2);
-
-            // v[2]
-            v2_outer.swap(0, 2);
-            v2_outer.swap(1, 3);
-
-            // v[3]
-            v3_outer.swap(2, 3);
-            v3_outer.swap(1, 2);
-            v3_outer.swap(0, 1);
-
-            // 3x (m3, R1, R2)
-            for i in 0..4usize {
-                cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
-                cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
-                cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
-
-                let v0 = v0_outer[i];
-                let v1 = v1_outer[i];
-                let v2 = v2_outer[i];
-                let v3 = v3_outer[i];
-                let m3 = event.b_reads[i + 8].value;
-                let zero1 = event.b_reads[i + 16].value;
-                let zero2 = event.b_reads[i + 20].value;
-                assert_eq!(zero1, 0);
-                assert_eq!(zero2, 0);
-
-                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-                let v0_new =
-                    cols.add[i + 16].populate(output, shard, event.channel, v0, v1, m3, zero1);
-                assert_eq!(v0 + v1 + m3 + zero1, v0_new);
-
-                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-                let temp = cols.xor[i + 16].populate(output, shard, event.channel, v3, v0_new);
-                let v3_new = cols.rotate_right[i + 16].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    temp,
-                    R_1 as usize,
-                );
-                assert_eq!((v3 ^ v0_new).rotate_right(R_1), v3_new);
-
-                // v[2] = v[2].wrapping_add(v[3]);
-                let v2_new = cols.add[i + 16 + 4].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    v2,
-                    v3_new,
-                    zero1,
-                    zero2,
-                );
-                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
-
-                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-                let temp = cols.xor[i + 16 + 4].populate(output, shard, event.channel, v1, v2_new);
-                let v1_new = cols.rotate_right[i + 16 + 4].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    temp,
-                    R_2 as usize,
-                );
-                assert_eq!((v1 ^ v2_new).rotate_right(R_2), v1_new);
-
-                v0_outer[i] = v0_new;
-                v1_outer[i] = v1_new;
-                v2_outer[i] = v2_new;
-                v3_outer[i] = v3_new;
-            }
-
-            // 4x (m4, R3, R4)
-            for i in 0..4usize {
-                let v0 = v0_outer[i];
-                let v1 = v1_outer[i];
-                let v2 = v2_outer[i];
-                let v3 = v3_outer[i];
-                let m4 = event.b_reads[i + 12].value;
-                let zero1 = event.b_reads[i + 16].value;
-                let zero2 = event.b_reads[i + 20].value;
-                assert_eq!(zero1, 0);
-                assert_eq!(zero2, 0);
-
-                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
-                let v0_new =
-                    cols.add[i + 16 + 8].populate(output, shard, event.channel, v0, v1, m4, zero1);
-                assert_eq!(v0 + v1 + m4 + zero1, v0_new);
-
-                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
-                //cols.unshuffled_indices[i + 12] = F::from_canonical_u32(1);
-                let temp = cols.xor[i + 16 + 8].populate(output, shard, event.channel, v3, v0_new);
-                //let v3_new = cols.rotate_right[v3_unshuffle_lookup[i] + 16 + 8].populate(
-                let v3_new = cols.rotate_right[i + 16 + 8].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    temp,
-                    R_3 as usize,
-                );
-                assert_eq!((v3 ^ v0_new).rotate_right(R_3), v3_new);
-
-                // v[2] = v[2].wrapping_add(v[3]);
-                //cols.unshuffled_indices[i + 8] = F::from_canonical_u32(1);
-                //let v2_new = cols.add[v2_unshuffle_lookup[i] + 16 + 4 + 8].populate(
-                let v2_new = cols.add[i + 16 + 4 + 8].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    v2,
-                    v3_new,
-                    zero1,
-                    zero2,
-                );
-                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
-
-                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
-                //cols.unshuffled_indices[i + 4] = F::from_canonical_u32(1);
-                let temp =
-                    cols.xor[i + 16 + 4 + 8].populate(output, shard, event.channel, v1, v2_new);
-                //let v1_new = cols.rotate_right[v1_unshuffle_lookup[i] + 16 + 4 + 8].populate(
-                let v1_new = cols.rotate_right[i + 16 + 4 + 8].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    temp,
-                    R_4 as usize,
-                );
-                assert_eq!((v1 ^ v2_new).rotate_right(R_4), v1_new);
-
-                //v0_outer[i] = v0_new;
-                //v1_outer[i] = v1_new;
-                //v2_outer[i] = v2_new;
-                //v3_outer[i] = v3_new;
-            }
-
-            /*
-            // unshuffle
-            // v[1]
-            v1_outer.swap(2, 3);
-            v1_outer.swap(1, 2);
-            v1_outer.swap(0, 1);
-
-            // v[2]
-            v2_outer.swap(0, 2);
-            v2_outer.swap(1, 3);
-
-            // v[3]
-            v3_outer.swap(0, 3);
-            v3_outer.swap(0, 1);
-            v3_outer.swap(1, 2);*/
-
-            //println!("4x traces: {:02x?}", [v0_outer, v1_outer, v2_outer, v3_outer].concat().to_vec());
-
-            rows.push(row);
-        }
-
-        output.add_byte_lookup_events(new_byte_lookup_events);
-
-        pad_rows(&mut rows, || {
-            let row = vec![F::zero(); width];
-
-            row
-        });
-
-        let mut trace =
-            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
-
-        // Write the nonces to the trace.
-        for i in 0..trace.height() {
-            let cols: &mut Blake2sRoundCols<F> =
-                trace.values[i * width..(i + 1) * width].borrow_mut();
-            cols.nonce = F::from_canonical_usize(i);
-        }
-
-        trace
-    }
-
-    fn included(&self, shard: &Self::Record) -> bool {
-        !shard.blake2s_round_events.is_empty()
-    }
-}
-
-impl<AB: SphinxAirBuilder> Air<AB> for Blake2sRoundChip
-where
-    AB::F: PrimeField32,
-{
-    fn eval(&self, builder: &mut AB) {
-        let main = builder.main();
-        let local = main.row_slice(0);
-        let next = main.row_slice(1);
-        let local: &Blake2sRoundCols<AB::Var> = (*local).borrow();
-        let next: &Blake2sRoundCols<AB::Var> = (*next).borrow();
-
-        // Constrain the incrementing nonce.
-        builder.when_first_row().assert_zero(local.nonce);
-        builder
-            .when_transition()
-            .assert_eq(local.nonce + AB::Expr::one(), next.nonce);
-
-        for i in 0..16usize {
-            // Eval a
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk + AB::F::from_canonical_u32(1), // We eval 'a' pointer access at clk+1 since 'a', 'b' could be the same,
-                local.a_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.a[i],
-                local.is_real,
-            );
-
-            // Eval b
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
-                local.is_real,
-            );
-        }
-
-        // zeroes
-        for i in 16..24usize {
-            // Eval b
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
-                local.is_real,
-            );
-        }
-
-        let v1_shuffle_lookup = vec![1, 2, 3, 0];
-        let v2_shuffle_lookup = vec![2, 3, 0, 1];
-        let v3_shuffle_lookup = vec![3, 0, 1, 2];
-
-        for i in 0..4usize {
-            // 1x
-
-            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-            Add4Operation::<AB::F>::eval(
-                builder,
-                *local.a[i].prev_value(),     // v0
-                *local.a[i + 4].prev_value(), // v1
-                *local.b[i].value(),          // m1
-                *local.b[i + 20].value(),     // zero1
-                local.shard,
-                local.channel,
-                local.is_real,
-                local.add[i],
-            );
-
-            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                *local.a[i + 12].prev_value(),
-                local.add[i].value,
-                local.xor[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i].value,
-                R_1 as usize,
-                local.rotate_right[i],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // v[2] = v[2].wrapping_add(v[3]);
-            Add4Operation::<AB::F>::eval(
-                builder,
-                *local.a[i + 8].prev_value(), // v2
-                local.rotate_right[i].value,  // v3 from previous operation
-                *local.b[i + 16].value(),     // zero1
-                *local.b[i + 20].value(),     // zero2
-                local.shard,
-                local.channel,
-                local.is_real,
-                local.add[i + 4],
-            );
-
-            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                *local.a[i + 4].prev_value(),
-                local.add[i + 4].value,
-                local.xor[i + 4],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i + 4].value,
-                R_2 as usize,
-                local.rotate_right[i + 4],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // 2x
-            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-            Add4Operation::<AB::F>::eval(
-                builder,
-                local.add[i].value,              // v0 after 1x
-                local.rotate_right[i + 4].value, // v1 after 1x
-                *local.b[i + 4].value(),         // m2
-                *local.b[i + 16].value(),        // zero1
-                local.shard,
-                local.channel,
-                local.is_real,
-                local.add[i + 8],
-            );
-
-            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                local.rotate_right[i].value, // v3 after 1x
-                local.add[i + 8].value,      // v0 after 1x
-                local.xor[i + 8],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i + 8].value,
-                R_3 as usize,
-                local.rotate_right[i + 8],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // v[2] = v[2].wrapping_add(v[3]);
-            Add4Operation::<AB::F>::eval(
-                builder,
-                local.add[i + 4].value,          // v2 after 1x
-                local.rotate_right[i + 8].value, // v3 after previous operation
-                *local.b[i + 16].value(),        // zero1
-                *local.b[i + 20].value(),        // zero2
-                local.shard,
-                local.channel,
-                local.is_real,
-                local.add[i + 12],
-            );
-
-            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                local.rotate_right[i + 4].value, // v1 after 1x
-                local.add[i + 12].value,         // v2 after previous operation
-                local.xor[i + 12],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i + 12].value,
-                R_4 as usize,
-                local.rotate_right[i + 12],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-        }
-
-        self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
-
-        for i in 0..4usize {
-            // 3x
-            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-            Add4Operation::<AB::F>::eval(
-                builder,
-                local.add[i + 8].value, // v0 after 2x
-                local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
-                *local.b[i + 8].value(), // m3
-                *local.b[i + 16].value(), // zero1
-                local.shard,
-                local.channel,
-                local.is_real,
-                local.add[i + 16],
-            );
-
-            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x
-                local.add[i + 16].value,                            // v0 after previous operation
-                local.xor[i + 16],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i + 16].value,
-                R_1 as usize,
-                local.rotate_right[i + 16],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // v[2] = v[2].wrapping_add(v[3]);
-            Add4Operation::<AB::F>::eval(
-                builder,
-                local.add[v2_shuffle_lookup[i] + 12].value, // v2 after 2x
-                local.rotate_right[i + 16].value,           // v3 after previous operation
-                *local.b[i + 16].value(),                   // zero1
-                *local.b[i + 20].value(),                   // zero2
-                local.shard,
-                local.channel,
-                local.is_real,
-                local.add[i + 20],
-            );
-
-            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
-                local.add[i + 20].value,                             // v2 after previous operation
-                local.xor[i + 20],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i + 20].value,
-                R_2 as usize,
-                local.rotate_right[i + 20],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // 4x
-            // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-            Add4Operation::<AB::F>::eval(
-                builder,
-                local.add[i + 16].value,          // v0 after 3x
-                local.rotate_right[i + 20].value, // v1 after 3x
-                *local.b[i + 12].value(),         // m4
-                *local.b[i + 16].value(),         // zero1
-                local.shard,
-                local.channel,
-                local.is_real,
-                local.add[i + 24],
-            );
-
-            // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                local.rotate_right[i + 16].value, // v3 after 3x
-                local.add[i + 24].value,          // v0 after previous operation
-                local.xor[i + 24],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i + 24].value,
-                R_3 as usize,
-                local.rotate_right[i + 24],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // v[2] = v[2].wrapping_add(v[3]);
-            Add4Operation::<AB::F>::eval(
-                builder,
-                local.add[i + 20].value,          // v2 after 3x
-                local.rotate_right[i + 24].value, // v3 after previous operation
-                *local.b[i + 16].value(),         // zero1
-                *local.b[i + 20].value(),         // zero2
-                local.shard,
-                local.channel,
-                local.is_real,
-                local.add[i + 28],
-            );
-
-            // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-            // Eval XOR
-            XorOperation::<AB::F>::eval(
-                builder,
-                local.rotate_right[i + 20].value, // v1 after 3x
-                local.add[i + 28].value,          // v2 after previous operation
-                local.xor[i + 28],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-
-            // Eval RotateRight
-            FixedRotateRightOperation::<AB::F>::eval(
-                builder,
-                local.xor[i + 28].value,
-                R_4 as usize,
-                local.rotate_right[i + 28],
-                local.shard,
-                &local.channel,
-                local.is_real,
-            );
-        }
-
-        /*self.constrain_shuffled_unshuffled_indices(
-            builder,
-            &local.unshuffled_indices,
-            local.is_real,
-        );*/
-
-        builder.receive_syscall(
-            local.shard,
-            local.channel,
-            local.clk,
-            local.nonce,
-            AB::F::from_canonical_u32(SyscallCode::BLAKE_2S_ROUND.syscall_id()),
-            local.a_ptr,
-            local.b_ptr,
-            local.is_real,
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::runtime::{Instruction, Opcode, SyscallCode};
-    use crate::syscall::precompiles::blake2s::blake2s_round;
-    use crate::utils::tests::BLAKE2S_ROUND_ELF;
-    use crate::utils::{run_test, run_test_with_memory_inspection, setup_logger};
-    use crate::Program;
-    use rand::Rng;
-
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 16], b: [u32; 24]) -> Program {
-        let mut instructions = vec![];
-        // memory write a
-        for (index, word) in a.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                a_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // memory write b
-        for (index, word) in b.into_iter().enumerate() {
-            instructions.push(Instruction::new(Opcode::ADD, 29, 0, word, false, true));
-            instructions.push(Instruction::new(
-                Opcode::ADD,
-                30,
-                0,
-                b_ptr + (index * 4) as u32,
-                false,
-                true,
-            ));
-            instructions.push(Instruction::new(Opcode::SW, 29, 30, 0, false, true));
-        }
-
-        // Syscall invocation
-        instructions.push(Instruction::new(
-            Opcode::ADD,
-            5,
-            0,
-            SyscallCode::BLAKE_2S_ROUND as u32,
-            false,
-            true,
-        ));
-        instructions.push(Instruction::new(Opcode::ADD, 10, 0, a_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ADD, 11, 0, b_ptr, false, true));
-        instructions.push(Instruction::new(Opcode::ECALL, 5, 10, 11, false, false));
-        Program::new(instructions, 0, 0)
-    }
-
-    #[test]
-    fn test_blake2s_round_precompile() {
-        setup_logger();
-
-        let a_ptr = 100100100;
-        let b_ptr = 200200200;
-
-        let a = rand::thread_rng().gen::<[u32; 16]>();
-        let mut a_clone = a.clone();
-        let mut b = rand::thread_rng().gen::<[u32; 24]>();
-        for item in b[0..24].iter_mut() {
-            *item = 0;
-        }
-
-        blake2s_round(&mut a_clone, &b);
-
-        let program = risc_v_program(a_ptr, b_ptr, a, b);
-
-        let (_, memory) = run_test_with_memory_inspection(program);
-        let mut result = vec![];
-        // result is 4 words, written to a_ptr
-        for i in 0..16 {
-            result.push(memory.get(&(a_ptr + i * 4)).unwrap().value);
-        }
-
-        assert_eq!(result, a_clone.to_vec());
-    }
-
-    #[test]
-    fn test_blake2s_round_program() {
-        setup_logger();
-        let program = Program::from(BLAKE2S_ROUND_ELF);
-        run_test(program).unwrap();
-    }
-}
diff --git a/core/src/syscall/precompiles/blake2s/trace.rs b/core/src/syscall/precompiles/blake2s/trace.rs
new file mode 100644
index 000000000..06d67e014
--- /dev/null
+++ b/core/src/syscall/precompiles/blake2s/trace.rs
@@ -0,0 +1,368 @@
+use crate::bytes::event::ByteRecord;
+use crate::syscall::precompiles::blake2s::Blake2sRoundCols;
+use crate::syscall::precompiles::blake2s::{
+    Blake2sRoundChip, Blake2sRoundEvent, R_1, R_2, R_3, R_4,
+};
+use crate::utils::pad_rows;
+use crate::{
+    air::{EventLens, MachineAir, WithEvents},
+    runtime::{ExecutionRecord, Program},
+};
+use core::borrow::BorrowMut;
+use p3_air::BaseAir;
+use p3_field::PrimeField32;
+use p3_matrix::dense::RowMajorMatrix;
+use p3_matrix::Matrix;
+
+impl<'a> WithEvents<'a> for Blake2sRoundChip {
+    type Events = &'a [Blake2sRoundEvent];
+}
+
+impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
+    type Record = ExecutionRecord;
+    type Program = Program;
+
+    fn name(&self) -> String {
+        "Blake2sRoundChip".to_string()
+    }
+
+    fn generate_trace<EL: EventLens<Self>>(
+        &self,
+        input: &EL,
+        output: &mut Self::Record,
+    ) -> RowMajorMatrix<F> {
+        let mut rows = vec![];
+        let width = <Blake2sRoundChip as BaseAir<F>>::width(self);
+        let mut new_byte_lookup_events = Vec::new();
+        for event in input.events() {
+            let shard = event.shard;
+            let mut row = vec![F::zero(); width];
+            let cols: &mut Blake2sRoundCols<F> = row.as_mut_slice().borrow_mut();
+
+            cols.clk = F::from_canonical_u32(event.clk);
+            cols.is_real = F::one();
+            cols.shard = F::from_canonical_u32(event.shard);
+            cols.channel = F::from_canonical_u32(event.channel);
+            cols.a_ptr = F::from_canonical_u32(event.a_ptr);
+            cols.b_ptr = F::from_canonical_u32(event.b_ptr);
+
+            // populate all v, m
+            for i in 0..16usize {
+                cols.a[i].populate(
+                    event.channel,
+                    event.a_reads_writes[i],
+                    &mut new_byte_lookup_events,
+                );
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+            }
+
+            // populate zeroes
+            for i in 16..24usize {
+                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
+            }
+
+            let mut v0_outer = vec![0u32; 4];
+            let mut v1_outer = vec![0u32; 4];
+            let mut v2_outer = vec![0u32; 4];
+            let mut v3_outer = vec![0u32; 4];
+
+            // 1x (m1, R1, R2)
+            for i in 0..4usize {
+                let v0 = event.a_reads_writes[i].prev_value;
+                let v1 = event.a_reads_writes[i + 4].prev_value;
+                let v2 = event.a_reads_writes[i + 8].prev_value;
+                let v3 = event.a_reads_writes[i + 12].prev_value;
+                let m1 = event.b_reads[i].value;
+                let zero1 = event.b_reads[i + 16].value;
+                let zero2 = event.b_reads[i + 20].value;
+                assert_eq!(zero1, 0);
+                assert_eq!(zero2, 0);
+
+                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+                let v0_new = cols.add[i].populate(output, shard, event.channel, v0, v1, m1, zero1);
+                assert_eq!(v0 + v1 + m1 + zero1, v0_new);
+
+                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+                let temp = cols.xor[i].populate(output, shard, event.channel, v3, v0_new);
+                let v3_new =
+                    cols.rotate_right[i].populate(output, shard, event.channel, temp, R_1 as usize);
+                assert_eq!((v3 ^ v0_new).rotate_right(R_1), v3_new);
+
+                // v[2] = v[2].wrapping_add(v[3]);
+                let v2_new = cols.add[i + 4].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    v2,
+                    v3_new,
+                    zero1,
+                    zero2,
+                );
+                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
+
+                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+                let temp = cols.xor[i + 4].populate(output, shard, event.channel, v1, v2_new);
+                let v1_new = cols.rotate_right[i + 4].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_2 as usize,
+                );
+                assert_eq!((v1 ^ v2_new).rotate_right(R_2), v1_new);
+
+                v0_outer[i] = v0_new;
+                v1_outer[i] = v1_new;
+                v2_outer[i] = v2_new;
+                v3_outer[i] = v3_new;
+            }
+
+            // 2x (m2, R3, R4)
+            for i in 0..4usize {
+                let v0 = v0_outer[i];
+                let v1 = v1_outer[i];
+                let v2 = v2_outer[i];
+                let v3 = v3_outer[i];
+                let m2 = event.b_reads[i + 4].value;
+                let zero1 = event.b_reads[i + 16].value;
+                let zero2 = event.b_reads[i + 20].value;
+                assert_eq!(zero1, 0);
+                assert_eq!(zero2, 0);
+
+                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
+                let v0_new =
+                    cols.add[i + 8].populate(output, shard, event.channel, v0, v1, m2, zero1);
+                assert_eq!(v0 + v1 + m2 + zero1, v0_new);
+
+                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
+                //cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
+                let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0_new);
+                //let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
+                let v3_new = cols.rotate_right[i + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_3 as usize,
+                );
+                assert_eq!((v3 ^ v0_new).rotate_right(R_3), v3_new);
+
+                // v[2] = v[2].wrapping_add(v[3]);
+                //cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
+                //let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
+                let v2_new = cols.add[i + 4 + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    v2,
+                    v3_new,
+                    zero1,
+                    zero2,
+                );
+                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
+
+                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
+                //cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
+                let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2_new);
+                //let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
+                let v1_new = cols.rotate_right[i + 4 + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_4 as usize,
+                );
+                assert_eq!((v1 ^ v2_new).rotate_right(R_4), v1_new);
+
+                v0_outer[i] = v0_new;
+                v1_outer[i] = v1_new;
+                v2_outer[i] = v2_new;
+                v3_outer[i] = v3_new;
+            }
+
+            // shuffle
+            // v[1]
+            v1_outer.swap(0, 3);
+            v1_outer.swap(0, 1);
+            v1_outer.swap(1, 2);
+
+            // v[2]
+            v2_outer.swap(0, 2);
+            v2_outer.swap(1, 3);
+
+            // v[3]
+            v3_outer.swap(2, 3);
+            v3_outer.swap(1, 2);
+            v3_outer.swap(0, 1);
+
+            // 3x (m3, R1, R2)
+            for i in 0..4usize {
+                cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
+                cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
+                cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
+
+                let v0 = v0_outer[i];
+                let v1 = v1_outer[i];
+                let v2 = v2_outer[i];
+                let v3 = v3_outer[i];
+                let m3 = event.b_reads[i + 8].value;
+                let zero1 = event.b_reads[i + 16].value;
+                let zero2 = event.b_reads[i + 20].value;
+                assert_eq!(zero1, 0);
+                assert_eq!(zero2, 0);
+
+                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
+                let v0_new =
+                    cols.add[i + 16].populate(output, shard, event.channel, v0, v1, m3, zero1);
+                assert_eq!(v0 + v1 + m3 + zero1, v0_new);
+
+                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
+                let temp = cols.xor[i + 16].populate(output, shard, event.channel, v3, v0_new);
+                let v3_new = cols.rotate_right[i + 16].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_1 as usize,
+                );
+                assert_eq!((v3 ^ v0_new).rotate_right(R_1), v3_new);
+
+                // v[2] = v[2].wrapping_add(v[3]);
+                let v2_new = cols.add[i + 16 + 4].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    v2,
+                    v3_new,
+                    zero1,
+                    zero2,
+                );
+                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
+
+                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
+                let temp = cols.xor[i + 16 + 4].populate(output, shard, event.channel, v1, v2_new);
+                let v1_new = cols.rotate_right[i + 16 + 4].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_2 as usize,
+                );
+                assert_eq!((v1 ^ v2_new).rotate_right(R_2), v1_new);
+
+                v0_outer[i] = v0_new;
+                v1_outer[i] = v1_new;
+                v2_outer[i] = v2_new;
+                v3_outer[i] = v3_new;
+            }
+
+            // 4x (m4, R3, R4)
+            for i in 0..4usize {
+                let v0 = v0_outer[i];
+                let v1 = v1_outer[i];
+                let v2 = v2_outer[i];
+                let v3 = v3_outer[i];
+                let m4 = event.b_reads[i + 12].value;
+                let zero1 = event.b_reads[i + 16].value;
+                let zero2 = event.b_reads[i + 20].value;
+                assert_eq!(zero1, 0);
+                assert_eq!(zero2, 0);
+
+                // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
+                let v0_new =
+                    cols.add[i + 16 + 8].populate(output, shard, event.channel, v0, v1, m4, zero1);
+                assert_eq!(v0 + v1 + m4 + zero1, v0_new);
+
+                // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
+                //cols.unshuffled_indices[i + 12] = F::from_canonical_u32(1);
+                let temp = cols.xor[i + 16 + 8].populate(output, shard, event.channel, v3, v0_new);
+                //let v3_new = cols.rotate_right[v3_unshuffle_lookup[i] + 16 + 8].populate(
+                let v3_new = cols.rotate_right[i + 16 + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_3 as usize,
+                );
+                assert_eq!((v3 ^ v0_new).rotate_right(R_3), v3_new);
+
+                // v[2] = v[2].wrapping_add(v[3]);
+                //cols.unshuffled_indices[i + 8] = F::from_canonical_u32(1);
+                //let v2_new = cols.add[v2_unshuffle_lookup[i] + 16 + 4 + 8].populate(
+                let v2_new = cols.add[i + 16 + 4 + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    v2,
+                    v3_new,
+                    zero1,
+                    zero2,
+                );
+                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
+
+                // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
+                //cols.unshuffled_indices[i + 4] = F::from_canonical_u32(1);
+                let temp =
+                    cols.xor[i + 16 + 4 + 8].populate(output, shard, event.channel, v1, v2_new);
+                //let v1_new = cols.rotate_right[v1_unshuffle_lookup[i] + 16 + 4 + 8].populate(
+                let v1_new = cols.rotate_right[i + 16 + 4 + 8].populate(
+                    output,
+                    shard,
+                    event.channel,
+                    temp,
+                    R_4 as usize,
+                );
+                assert_eq!((v1 ^ v2_new).rotate_right(R_4), v1_new);
+
+                //v0_outer[i] = v0_new;
+                //v1_outer[i] = v1_new;
+                //v2_outer[i] = v2_new;
+                //v3_outer[i] = v3_new;
+            }
+
+            /*
+            // unshuffle
+            // v[1]
+            v1_outer.swap(2, 3);
+            v1_outer.swap(1, 2);
+            v1_outer.swap(0, 1);
+
+            // v[2]
+            v2_outer.swap(0, 2);
+            v2_outer.swap(1, 3);
+
+            // v[3]
+            v3_outer.swap(0, 3);
+            v3_outer.swap(0, 1);
+            v3_outer.swap(1, 2);*/
+
+            //println!("4x traces: {:02x?}", [v0_outer, v1_outer, v2_outer, v3_outer].concat().to_vec());
+
+            rows.push(row);
+        }
+
+        output.add_byte_lookup_events(new_byte_lookup_events);
+
+        pad_rows(&mut rows, || {
+            let row = vec![F::zero(); width];
+
+            row
+        });
+
+        let mut trace =
+            RowMajorMatrix::<F>::new(rows.into_iter().flatten().collect::<Vec<_>>(), width);
+
+        // Write the nonces to the trace.
+        for i in 0..trace.height() {
+            let cols: &mut Blake2sRoundCols<F> =
+                trace.values[i * width..(i + 1) * width].borrow_mut();
+            cols.nonce = F::from_canonical_usize(i);
+        }
+
+        trace
+    }
+
+    fn included(&self, shard: &Self::Record) -> bool {
+        !shard.blake2s_round_events.is_empty()
+    }
+}

From 04fa3d1caa83c21d7a6acaaa64f17ec41ee3665e Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 23 Sep 2024 14:51:39 +0300
Subject: [PATCH 26/30] chore: Cleanup

---
 core/src/syscall/precompiles/blake2s/air.rs   | 29 +--------
 .../syscall/precompiles/blake2s/execute.rs    |  9 +--
 core/src/syscall/precompiles/blake2s/trace.rs | 61 +++----------------
 3 files changed, 15 insertions(+), 84 deletions(-)

diff --git a/core/src/syscall/precompiles/blake2s/air.rs b/core/src/syscall/precompiles/blake2s/air.rs
index 0a0e57759..15ab346ce 100644
--- a/core/src/syscall/precompiles/blake2s/air.rs
+++ b/core/src/syscall/precompiles/blake2s/air.rs
@@ -55,9 +55,8 @@ where
             );
         }
 
-        // zeroes
+        // Eval extra-zeroes
         for i in 16..24usize {
-            // Eval b
             builder.eval_memory_access(
                 local.shard,
                 local.channel,
@@ -89,7 +88,6 @@ where
             );
 
             // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-            // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 *local.a[i + 12].prev_value(),
@@ -99,8 +97,6 @@ where
                 &local.channel,
                 local.is_real,
             );
-
-            // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
                 local.xor[i].value,
@@ -125,7 +121,6 @@ where
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-            // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 *local.a[i + 4].prev_value(),
@@ -135,8 +130,6 @@ where
                 &local.channel,
                 local.is_real,
             );
-
-            // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
                 local.xor[i + 4].value,
@@ -148,6 +141,7 @@ where
             );
 
             // 2x
+
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
                 builder,
@@ -162,7 +156,6 @@ where
             );
 
             // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-            // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i].value, // v3 after 1x
@@ -172,8 +165,6 @@ where
                 &local.channel,
                 local.is_real,
             );
-
-            // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
                 local.xor[i + 8].value,
@@ -198,7 +189,6 @@ where
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-            // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i + 4].value, // v1 after 1x
@@ -208,8 +198,6 @@ where
                 &local.channel,
                 local.is_real,
             );
-
-            // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
                 local.xor[i + 12].value,
@@ -225,6 +213,7 @@ where
 
         for i in 0..4usize {
             // 3x
+
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
             Add4Operation::<AB::F>::eval(
                 builder,
@@ -239,7 +228,6 @@ where
             );
 
             // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-            // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x
@@ -249,8 +237,6 @@ where
                 &local.channel,
                 local.is_real,
             );
-
-            // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
                 local.xor[i + 16].value,
@@ -275,7 +261,6 @@ where
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-            // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
@@ -285,8 +270,6 @@ where
                 &local.channel,
                 local.is_real,
             );
-
-            // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
                 local.xor[i + 20].value,
@@ -312,7 +295,6 @@ where
             );
 
             // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
-            // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i + 16].value, // v3 after 3x
@@ -322,8 +304,6 @@ where
                 &local.channel,
                 local.is_real,
             );
-
-            // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
                 local.xor[i + 24].value,
@@ -348,7 +328,6 @@ where
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
-            // Eval XOR
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i + 20].value, // v1 after 3x
@@ -358,8 +337,6 @@ where
                 &local.channel,
                 local.is_real,
             );
-
-            // Eval RotateRight
             FixedRotateRightOperation::<AB::F>::eval(
                 builder,
                 local.xor[i + 28].value,
diff --git a/core/src/syscall/precompiles/blake2s/execute.rs b/core/src/syscall/precompiles/blake2s/execute.rs
index 06f415bf7..c4e7b5d0d 100644
--- a/core/src/syscall/precompiles/blake2s/execute.rs
+++ b/core/src/syscall/precompiles/blake2s/execute.rs
@@ -18,7 +18,7 @@ impl Syscall for Blake2sRoundChip {
 
         let (b_reads, b) = ctx.mr_slice(b_ptr, 24);
 
-        // 1x (m1, R1, R2)
+        // 1x (m0, R1, R2)
         // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m1)
         for ((v0, v1), m) in a[0..4]
             .iter_mut()
@@ -46,7 +46,7 @@ impl Syscall for Blake2sRoundChip {
             *v1 = (*v1 ^ *v2).rotate_right(R_2);
         }
 
-        // 2x (m2, R3, R4)
+        // 2x (m1, R3, R4)
         let mut a = a.clone(); // a after 1x quarter_round
         let mut a_clone = a.clone();
 
@@ -95,7 +95,7 @@ impl Syscall for Blake2sRoundChip {
         let mut a = a.clone(); // a after 2x quarter_round
         let mut a_clone = a.clone();
 
-        // 3x (m3, R1, R2)
+        // 3x (m2, R1, R2)
         // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m3)
         for ((v0, v1), m) in a[0..4]
             .iter_mut()
@@ -123,7 +123,7 @@ impl Syscall for Blake2sRoundChip {
             *v1 = (*v1 ^ *v2).rotate_right(R_2);
         }
 
-        // 4x (m4, R3, R4)
+        // 4x (m3, R3, R4)
         let mut a = a.clone(); // a after 3x quarter_round
         let mut a_clone = a.clone();
 
@@ -170,6 +170,7 @@ impl Syscall for Blake2sRoundChip {
         a[12..16].swap(1, 2);
 
         ctx.clk += 1;
+
         // Write rotate_right to a_ptr.
         let a_reads_writes = ctx.mw_slice(a_ptr, a.as_slice());
 
diff --git a/core/src/syscall/precompiles/blake2s/trace.rs b/core/src/syscall/precompiles/blake2s/trace.rs
index 06d67e014..ec95db0eb 100644
--- a/core/src/syscall/precompiles/blake2s/trace.rs
+++ b/core/src/syscall/precompiles/blake2s/trace.rs
@@ -56,7 +56,8 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
             }
 
-            // populate zeroes
+            // populate extra-zeroes
+            // TODO: replace Add4 with Add3 operation and avoid this
             for i in 16..24usize {
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
             }
@@ -66,7 +67,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
             let mut v2_outer = vec![0u32; 4];
             let mut v3_outer = vec![0u32; 4];
 
-            // 1x (m1, R1, R2)
+            // 1x (m0, R1, R2)
             for i in 0..4usize {
                 let v0 = event.a_reads_writes[i].prev_value;
                 let v1 = event.a_reads_writes[i + 4].prev_value;
@@ -80,13 +81,11 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
 
                 // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
                 let v0_new = cols.add[i].populate(output, shard, event.channel, v0, v1, m1, zero1);
-                assert_eq!(v0 + v1 + m1 + zero1, v0_new);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
                 let temp = cols.xor[i].populate(output, shard, event.channel, v3, v0_new);
                 let v3_new =
                     cols.rotate_right[i].populate(output, shard, event.channel, temp, R_1 as usize);
-                assert_eq!((v3 ^ v0_new).rotate_right(R_1), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
                 let v2_new = cols.add[i + 4].populate(
@@ -98,7 +97,6 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                     zero1,
                     zero2,
                 );
-                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
                 let temp = cols.xor[i + 4].populate(output, shard, event.channel, v1, v2_new);
@@ -109,7 +107,6 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                     temp,
                     R_2 as usize,
                 );
-                assert_eq!((v1 ^ v2_new).rotate_right(R_2), v1_new);
 
                 v0_outer[i] = v0_new;
                 v1_outer[i] = v1_new;
@@ -117,7 +114,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 v3_outer[i] = v3_new;
             }
 
-            // 2x (m2, R3, R4)
+            // 2x (m1, R3, R4)
             for i in 0..4usize {
                 let v0 = v0_outer[i];
                 let v1 = v1_outer[i];
@@ -126,18 +123,13 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 let m2 = event.b_reads[i + 4].value;
                 let zero1 = event.b_reads[i + 16].value;
                 let zero2 = event.b_reads[i + 20].value;
-                assert_eq!(zero1, 0);
-                assert_eq!(zero2, 0);
 
                 // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
                 let v0_new =
                     cols.add[i + 8].populate(output, shard, event.channel, v0, v1, m2, zero1);
-                assert_eq!(v0 + v1 + m2 + zero1, v0_new);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
-                //cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0_new);
-                //let v3_new = cols.rotate_right[v3_shuffle_lookup[i] + 8].populate(
                 let v3_new = cols.rotate_right[i + 8].populate(
                     output,
                     shard,
@@ -145,11 +137,8 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                     temp,
                     R_3 as usize,
                 );
-                assert_eq!((v3 ^ v0_new).rotate_right(R_3), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                //cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
-                //let v2_new = cols.add[v2_shuffle_lookup[i] + 4 + 8].populate(
                 let v2_new = cols.add[i + 4 + 8].populate(
                     output,
                     shard,
@@ -159,12 +148,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                     zero1,
                     zero2,
                 );
-                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
-                //cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2_new);
-                //let v1_new = cols.rotate_right[v1_shuffle_lookup[i] + 4 + 8].populate(
                 let v1_new = cols.rotate_right[i + 4 + 8].populate(
                     output,
                     shard,
@@ -172,7 +158,6 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                     temp,
                     R_4 as usize,
                 );
-                assert_eq!((v1 ^ v2_new).rotate_right(R_4), v1_new);
 
                 v0_outer[i] = v0_new;
                 v1_outer[i] = v1_new;
@@ -195,7 +180,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
             v3_outer.swap(1, 2);
             v3_outer.swap(0, 1);
 
-            // 3x (m3, R1, R2)
+            // 3x (m2, R1, R2)
             for i in 0..4usize {
                 cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
                 cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
@@ -256,7 +241,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 v3_outer[i] = v3_new;
             }
 
-            // 4x (m4, R3, R4)
+            // 4x (m3, R3, R4)
             for i in 0..4usize {
                 let v0 = v0_outer[i];
                 let v1 = v1_outer[i];
@@ -274,9 +259,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 assert_eq!(v0 + v1 + m4 + zero1, v0_new);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
-                //cols.unshuffled_indices[i + 12] = F::from_canonical_u32(1);
                 let temp = cols.xor[i + 16 + 8].populate(output, shard, event.channel, v3, v0_new);
-                //let v3_new = cols.rotate_right[v3_unshuffle_lookup[i] + 16 + 8].populate(
                 let v3_new = cols.rotate_right[i + 16 + 8].populate(
                     output,
                     shard,
@@ -287,8 +270,6 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 assert_eq!((v3 ^ v0_new).rotate_right(R_3), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                //cols.unshuffled_indices[i + 8] = F::from_canonical_u32(1);
-                //let v2_new = cols.add[v2_unshuffle_lookup[i] + 16 + 4 + 8].populate(
                 let v2_new = cols.add[i + 16 + 4 + 8].populate(
                     output,
                     shard,
@@ -298,46 +279,18 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                     zero1,
                     zero2,
                 );
-                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
-                //cols.unshuffled_indices[i + 4] = F::from_canonical_u32(1);
                 let temp =
                     cols.xor[i + 16 + 4 + 8].populate(output, shard, event.channel, v1, v2_new);
-                //let v1_new = cols.rotate_right[v1_unshuffle_lookup[i] + 16 + 4 + 8].populate(
-                let v1_new = cols.rotate_right[i + 16 + 4 + 8].populate(
+                let _v1_new = cols.rotate_right[i + 16 + 4 + 8].populate(
                     output,
                     shard,
                     event.channel,
                     temp,
                     R_4 as usize,
                 );
-                assert_eq!((v1 ^ v2_new).rotate_right(R_4), v1_new);
-
-                //v0_outer[i] = v0_new;
-                //v1_outer[i] = v1_new;
-                //v2_outer[i] = v2_new;
-                //v3_outer[i] = v3_new;
             }
-
-            /*
-            // unshuffle
-            // v[1]
-            v1_outer.swap(2, 3);
-            v1_outer.swap(1, 2);
-            v1_outer.swap(0, 1);
-
-            // v[2]
-            v2_outer.swap(0, 2);
-            v2_outer.swap(1, 3);
-
-            // v[3]
-            v3_outer.swap(0, 3);
-            v3_outer.swap(0, 1);
-            v3_outer.swap(1, 2);*/
-
-            //println!("4x traces: {:02x?}", [v0_outer, v1_outer, v2_outer, v3_outer].concat().to_vec());
-
             rows.push(row);
         }
 

From b4c74f8f6fc735c57feb0a36c0aeb6b8d537996a Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 23 Sep 2024 15:15:33 +0300
Subject: [PATCH 27/30] chore: Clippy

---
 core/src/stark/air.rs                         |  2 +-
 core/src/syscall/precompiles/blake2s/air.rs   |  6 ++---
 core/src/syscall/precompiles/blake2s/mod.rs   | 27 +++++++++----------
 core/src/syscall/precompiles/blake2s/trace.rs |  8 +++---
 4 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index 3b4d61efc..af094bb27 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -184,7 +184,7 @@ impl<F: PrimeField32> RiscvAir<F> {
         chips.push(RiscvAir::ProgramMemory(program_memory_init));
         let byte = ByteChip::default();
         chips.push(RiscvAir::ByteLookup(byte));
-        let blake_2s_round = Blake2sRoundChip::default();
+        let blake_2s_round = Blake2sRoundChip::new();
         chips.push(RiscvAir::Blake2sRound(blake_2s_round));
 
         chips
diff --git a/core/src/syscall/precompiles/blake2s/air.rs b/core/src/syscall/precompiles/blake2s/air.rs
index 15ab346ce..d70f0d6f2 100644
--- a/core/src/syscall/precompiles/blake2s/air.rs
+++ b/core/src/syscall/precompiles/blake2s/air.rs
@@ -67,9 +67,9 @@ where
             );
         }
 
-        let v1_shuffle_lookup = vec![1, 2, 3, 0];
-        let v2_shuffle_lookup = vec![2, 3, 0, 1];
-        let v3_shuffle_lookup = vec![3, 0, 1, 2];
+        let v1_shuffle_lookup = [1, 2, 3, 0];
+        let v2_shuffle_lookup = [2, 3, 0, 1];
+        let v3_shuffle_lookup = [3, 0, 1, 2];
 
         for i in 0..4usize {
             // 1x
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index 1d7cd20c2..db178b42f 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -106,26 +106,30 @@ fn rotate_right_const(a: [u32; 4], n: u32) -> [u32; 4] {
         a[3].rotate_right(n),
     ]
 }
-fn quarter_round(v: &mut Vec<[u32; 4]>, rd: u32, rb: u32, m: [u32; 4]) {
+fn quarter_round(v: &mut [[u32; 4]], rd: u32, rb: u32, m: [u32; 4]) {
     v[0] = wrapping_add_u32x4(wrapping_add_u32x4(v[0], v[1]), m); // m.from_le (?)
     v[3] = rotate_right_const(xor_u32x4(v[3], v[0]), rd);
     v[2] = wrapping_add_u32x4(v[2], v[3]);
     v[1] = rotate_right_const(xor_u32x4(v[1], v[2]), rb);
 }
-fn shuffle(v: &mut Vec<[u32; 4]>) {
+fn shuffle(v: &mut [[u32; 4]]) {
     v[1] = shuffle_left_1_u32x4(v[1]);
     v[2] = shuffle_left_2_u32x4(v[2]);
     v[3] = shuffle_left_3_u32x4(v[3]);
 }
-fn unshuffle(v: &mut Vec<[u32; 4]>) {
+fn unshuffle(v: &mut [[u32; 4]]) {
     v[1] = shuffle_right_1_u32x4(v[1]);
     v[2] = shuffle_right_2_u32x4(v[2]);
     v[3] = shuffle_right_3_u32x4(v[3]);
 }
+
+#[allow(dead_code)]
 fn gather(m: [u32; 16], i0: usize, i1: usize, i2: usize, i3: usize) -> [u32; 4] {
     [m[i0], m[i1], m[i2], m[i3]]
 }
-fn round(v: &mut Vec<[u32; 4]>, m: [u32; 16], s: [usize; 16]) {
+
+#[allow(dead_code)]
+fn round(v: &mut [[u32; 4]], m: [u32; 16], s: [usize; 16]) {
     let r1 = 16;
     let r2 = 12;
     let r3 = 8;
@@ -235,7 +239,7 @@ mod tests {
         let b_ptr = 200200200;
 
         let a = rand::thread_rng().gen::<[u32; 16]>();
-        let mut a_clone = a.clone();
+        let mut a_clone = a;
         let mut b = rand::thread_rng().gen::<[u32; 24]>();
         for item in b[0..24].iter_mut() {
             *item = 0;
@@ -264,14 +268,9 @@ mod tests {
 
     #[test]
     fn test_blake2s_round_function() {
-        fn test_inner(
-            input: &mut Vec<[u32; 4]>,
-            m: [u32; 16],
-            s: [usize; 16],
-            output: Vec<[u32; 4]>,
-        ) {
+        fn test_inner(input: &mut [[u32; 4]], m: [u32; 16], s: [usize; 16], output: &[[u32; 4]]) {
             round(input, m, s);
-            assert_eq!(input.clone(), output);
+            assert_eq!(input.to_vec(), output.to_vec());
         }
 
         let mut v: Vec<[u32; 4]> = vec![
@@ -294,7 +293,7 @@ mod tests {
             &mut v,
             m,
             s,
-            vec![
+            &[
                 [0x82a01b5d, 0x248bd8f5, 0x1da4b59a, 0xb37b2bd3],
                 [0x515f5af4, 0x0301095b, 0xb151a3c2, 0x5e17f96f],
                 [0xc561666d, 0x0f291605, 0x990c6d13, 0x76fff6f1],
@@ -322,7 +321,7 @@ mod tests {
             &mut v,
             m,
             s,
-            vec![
+            &[
                 [0x071e8a60, 0x071e8a60, 0x071e8a60, 0x071e8a60],
                 [0x072df44c, 0x072df44c, 0x072df44c, 0x072df44c],
                 [0x522ca035, 0x522ca035, 0x522ca035, 0x522ca035],
diff --git a/core/src/syscall/precompiles/blake2s/trace.rs b/core/src/syscall/precompiles/blake2s/trace.rs
index ec95db0eb..d710f0fd8 100644
--- a/core/src/syscall/precompiles/blake2s/trace.rs
+++ b/core/src/syscall/precompiles/blake2s/trace.rs
@@ -62,10 +62,10 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
             }
 
-            let mut v0_outer = vec![0u32; 4];
-            let mut v1_outer = vec![0u32; 4];
-            let mut v2_outer = vec![0u32; 4];
-            let mut v3_outer = vec![0u32; 4];
+            let mut v0_outer = [0u32; 4];
+            let mut v1_outer = [0u32; 4];
+            let mut v2_outer = [0u32; 4];
+            let mut v3_outer = [0u32; 4];
 
             // 1x (m0, R1, R2)
             for i in 0..4usize {

From 6c41a9bba9a432fde2e0efff22935b49ee6b30d7 Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 23 Sep 2024 16:49:14 +0300
Subject: [PATCH 28/30] ci: Fixing check-downstream-compile(loam) job

---
 .github/workflows/tests.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 9d7bb335b..da45141a4 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -171,7 +171,7 @@ jobs:
           - repo: zk-light-clients
             path: ethereum
             features: ethereum
-          - repo: loam
+          - repo: lurk
             path: ""
     steps:
       - uses: actions/checkout@v4

From 35085fbe647b64787a94e0d0ede355a69ae5081b Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Mon, 23 Sep 2024 16:51:21 +0300
Subject: [PATCH 29/30] feat: Introduce Add3 operation

---
 core/src/operations/add3.rs                   | 134 ++++++++++++++++++
 core/src/operations/mod.rs                    |   2 +
 core/src/syscall/precompiles/blake2s/air.rs   |  94 +++++-------
 .../syscall/precompiles/blake2s/columns.rs    |   9 +-
 .../syscall/precompiles/blake2s/execute.rs    |   2 +-
 core/src/syscall/precompiles/blake2s/mod.rs   |  12 +-
 core/src/syscall/precompiles/blake2s/trace.rs |  77 ++--------
 tests/blake2s-round/Cargo.lock                |   2 +-
 tests/blake2s-round/Cargo.toml                |   2 +-
 .../elf/riscv32im-succinct-zkvm-elf           | Bin 22700 -> 22700 bytes
 tests/blake2s-round/src/main.rs               |   2 +-
 11 files changed, 190 insertions(+), 146 deletions(-)
 create mode 100644 core/src/operations/add3.rs

diff --git a/core/src/operations/add3.rs b/core/src/operations/add3.rs
new file mode 100644
index 000000000..0366f79ae
--- /dev/null
+++ b/core/src/operations/add3.rs
@@ -0,0 +1,134 @@
+use p3_air::AirBuilder;
+use p3_field::{AbstractField, Field};
+use sphinx_derive::AlignedBorrow;
+
+use crate::air::Word;
+use crate::air::WordAirBuilder;
+use crate::air::WORD_SIZE;
+use crate::bytes::event::ByteRecord;
+
+/// A set of columns needed to compute the add of three words.
+#[derive(AlignedBorrow, Default, Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Add3Operation<T> {
+    /// The result of `a + b + c`.
+    pub value: Word<T>,
+
+    /// Indicates if the carry for the `i`th digit is 0.
+    pub is_carry_0: Word<T>,
+
+    /// Indicates if the carry for the `i`th digit is 1.
+    pub is_carry_1: Word<T>,
+
+    /// Indicates if the carry for the `i`th digit is 2. The carry when adding 3 words is at most 2.
+    pub is_carry_2: Word<T>,
+
+    /// The carry for the `i`th digit.
+    pub carry: Word<T>,
+}
+
+impl<F: Field> Add3Operation<F> {
+    pub fn populate(
+        &mut self,
+        record: &mut impl ByteRecord,
+        shard: u32,
+        channel: u32,
+        a_u32: u32,
+        b_u32: u32,
+        c_u32: u32,
+    ) -> u32 {
+        let expected = a_u32.wrapping_add(b_u32).wrapping_add(c_u32);
+
+        self.value = Word::from(expected);
+        let a = a_u32.to_le_bytes();
+        let b = b_u32.to_le_bytes();
+        let c = c_u32.to_le_bytes();
+
+        let base = 256;
+        let mut carry = [0u8, 0u8, 0u8, 0u8];
+        for i in 0..WORD_SIZE {
+            let mut res = u32::from(a[i]) + u32::from(b[i]) + u32::from(c[i]);
+            if i > 0 {
+                res += u32::from(carry[i - 1]);
+            }
+            carry[i] = (res / base) as u8;
+            self.is_carry_0[i] = F::from_bool(carry[i] == 0);
+            self.is_carry_1[i] = F::from_bool(carry[i] == 1);
+            self.is_carry_2[i] = F::from_bool(carry[i] == 2);
+            self.carry[i] = F::from_canonical_u8(carry[i]);
+            debug_assert!(carry[i] <= 2);
+            debug_assert_eq!(self.value[i], F::from_canonical_u32(res % base));
+        }
+
+        // Range check.
+        {
+            record.add_u8_range_checks(shard, channel, &a);
+            record.add_u8_range_checks(shard, channel, &b);
+            record.add_u8_range_checks(shard, channel, &c);
+            record.add_u8_range_checks(shard, channel, &expected.to_le_bytes());
+        }
+        expected
+    }
+
+    pub fn eval<AB: WordAirBuilder<F = F>>(
+        builder: &mut AB,
+        a: Word<AB::Var>,
+        b: Word<AB::Var>,
+        c: Word<AB::Var>,
+        shard: AB::Var,
+        channel: impl Into<AB::Expr> + Copy,
+        is_real: AB::Var,
+        cols: Add3Operation<AB::Var>,
+    ) {
+        // Range check each byte.
+        {
+            builder.slice_range_check_u8(&a.0, shard, channel, is_real);
+            builder.slice_range_check_u8(&b.0, shard, channel, is_real);
+            builder.slice_range_check_u8(&c.0, shard, channel, is_real);
+            builder.slice_range_check_u8(&cols.value.0, shard, channel, is_real);
+        }
+
+        builder.assert_bool(is_real);
+        let mut builder_is_real = builder.when(is_real);
+
+        // Each value in is_carry_{0,1,2,3} is 0 or 1, and exactly one of them is 1 per digit.
+        {
+            for i in 0..WORD_SIZE {
+                builder_is_real.assert_bool(cols.is_carry_0[i]);
+                builder_is_real.assert_bool(cols.is_carry_1[i]);
+                builder_is_real.assert_bool(cols.is_carry_2[i]);
+                builder_is_real.assert_eq(
+                    cols.is_carry_0[i] + cols.is_carry_1[i] + cols.is_carry_2[i],
+                    AB::Expr::one(),
+                );
+            }
+        }
+
+        // Calculates carry from is_carry_{0,1,2}.
+        {
+            let one = AB::Expr::one();
+            let two = AB::F::from_canonical_u32(2);
+
+            for i in 0..WORD_SIZE {
+                builder_is_real.assert_eq(
+                    cols.carry[i],
+                    cols.is_carry_1[i] * one.clone() + cols.is_carry_2[i] * two,
+                );
+            }
+        }
+
+        // Compare the sum and summands by looking at carry.
+        {
+            let base = AB::F::from_canonical_u32(256);
+            // For each limb, assert that difference between the carried result and the non-carried
+            // result is the product of carry and base.
+            for i in 0..WORD_SIZE {
+                let mut overflow = a[i] + b[i] + c[i] - cols.value[i];
+                if i > 0 {
+                    overflow += cols.carry[i - 1].into();
+                }
+                builder_is_real.assert_eq(cols.carry[i] * base, overflow.clone());
+            }
+        }
+    }
+}
diff --git a/core/src/operations/mod.rs b/core/src/operations/mod.rs
index e3fbcc78b..52a17847d 100644
--- a/core/src/operations/mod.rs
+++ b/core/src/operations/mod.rs
@@ -5,6 +5,7 @@
 //! the constraints.
 
 mod add;
+mod add3;
 mod add4;
 mod add5;
 mod and;
@@ -21,6 +22,7 @@ mod or;
 mod xor;
 
 pub use add::*;
+pub use add3::*;
 pub use add4::*;
 pub use add5::*;
 pub use and::*;
diff --git a/core/src/syscall/precompiles/blake2s/air.rs b/core/src/syscall/precompiles/blake2s/air.rs
index d70f0d6f2..d054431dc 100644
--- a/core/src/syscall/precompiles/blake2s/air.rs
+++ b/core/src/syscall/precompiles/blake2s/air.rs
@@ -1,5 +1,5 @@
 use crate::memory::MemoryCols;
-use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation};
+use crate::operations::{Add3Operation, AddOperation, FixedRotateRightOperation, XorOperation};
 use crate::runtime::SyscallCode;
 use crate::stark::SphinxAirBuilder;
 use crate::syscall::precompiles::blake2s::columns::Blake2sRoundCols;
@@ -55,18 +55,6 @@ where
             );
         }
 
-        // Eval extra-zeroes
-        for i in 16..24usize {
-            builder.eval_memory_access(
-                local.shard,
-                local.channel,
-                local.clk,
-                local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4),
-                &local.b[i],
-                local.is_real,
-            );
-        }
-
         let v1_shuffle_lookup = [1, 2, 3, 0];
         let v2_shuffle_lookup = [2, 3, 0, 1];
         let v3_shuffle_lookup = [3, 0, 1, 2];
@@ -75,23 +63,22 @@ where
             // 1x
 
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-            Add4Operation::<AB::F>::eval(
+            Add3Operation::<AB::F>::eval(
                 builder,
                 *local.a[i].prev_value(),     // v0
                 *local.a[i + 4].prev_value(), // v1
                 *local.b[i].value(),          // m1
-                *local.b[i + 20].value(),     // zero1
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[i],
+                local.add3[i],
             );
 
             // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
             XorOperation::<AB::F>::eval(
                 builder,
                 *local.a[i + 12].prev_value(),
-                local.add[i].value,
+                local.add3[i].value,
                 local.xor[i],
                 local.shard,
                 &local.channel,
@@ -108,23 +95,21 @@ where
             );
 
             // v[2] = v[2].wrapping_add(v[3]);
-            Add4Operation::<AB::F>::eval(
+            AddOperation::<AB::F>::eval(
                 builder,
                 *local.a[i + 8].prev_value(), // v2
                 local.rotate_right[i].value,  // v3 from previous operation
-                *local.b[i + 16].value(),     // zero1
-                *local.b[i + 20].value(),     // zero2
+                local.add2[i],
                 local.shard,
                 local.channel,
-                local.is_real,
-                local.add[i + 4],
+                local.is_real.into(),
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
             XorOperation::<AB::F>::eval(
                 builder,
                 *local.a[i + 4].prev_value(),
-                local.add[i + 4].value,
+                local.add2[i].value,
                 local.xor[i + 4],
                 local.shard,
                 &local.channel,
@@ -143,23 +128,22 @@ where
             // 2x
 
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-            Add4Operation::<AB::F>::eval(
+            Add3Operation::<AB::F>::eval(
                 builder,
-                local.add[i].value,              // v0 after 1x
+                local.add3[i].value,             // v0 after 1x
                 local.rotate_right[i + 4].value, // v1 after 1x
                 *local.b[i + 4].value(),         // m2
-                *local.b[i + 16].value(),        // zero1
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[i + 8],
+                local.add3[i + 4],
             );
 
             // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i].value, // v3 after 1x
-                local.add[i + 8].value,      // v0 after 1x
+                local.add3[i + 4].value,     // v0 after 1x
                 local.xor[i + 8],
                 local.shard,
                 &local.channel,
@@ -176,23 +160,21 @@ where
             );
 
             // v[2] = v[2].wrapping_add(v[3]);
-            Add4Operation::<AB::F>::eval(
+            AddOperation::<AB::F>::eval(
                 builder,
-                local.add[i + 4].value,          // v2 after 1x
+                local.add2[i].value,             // v2 after 1x
                 local.rotate_right[i + 8].value, // v3 after previous operation
-                *local.b[i + 16].value(),        // zero1
-                *local.b[i + 20].value(),        // zero2
+                local.add2[i + 4],
                 local.shard,
                 local.channel,
-                local.is_real,
-                local.add[i + 12],
+                local.is_real.into(),
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i + 4].value, // v1 after 1x
-                local.add[i + 12].value,         // v2 after previous operation
+                local.add2[i + 4].value,         // v2 after previous operation
                 local.xor[i + 12],
                 local.shard,
                 &local.channel,
@@ -215,23 +197,22 @@ where
             // 3x
 
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-            Add4Operation::<AB::F>::eval(
+            Add3Operation::<AB::F>::eval(
                 builder,
-                local.add[i + 8].value, // v0 after 2x
+                local.add3[i + 4].value, // v0 after 2x
                 local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
                 *local.b[i + 8].value(), // m3
-                *local.b[i + 16].value(), // zero1
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[i + 16],
+                local.add3[i + 8],
             );
 
             // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x
-                local.add[i + 16].value,                            // v0 after previous operation
+                local.add3[i + 8].value,                            // v0 after previous operation
                 local.xor[i + 16],
                 local.shard,
                 &local.channel,
@@ -248,23 +229,21 @@ where
             );
 
             // v[2] = v[2].wrapping_add(v[3]);
-            Add4Operation::<AB::F>::eval(
+            AddOperation::<AB::F>::eval(
                 builder,
-                local.add[v2_shuffle_lookup[i] + 12].value, // v2 after 2x
+                local.add2[v2_shuffle_lookup[i] + 4].value, // v2 after 2x
                 local.rotate_right[i + 16].value,           // v3 after previous operation
-                *local.b[i + 16].value(),                   // zero1
-                *local.b[i + 20].value(),                   // zero2
+                local.add2[i + 8],
                 local.shard,
                 local.channel,
-                local.is_real,
-                local.add[i + 20],
+                local.is_real.into(),
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x
-                local.add[i + 20].value,                             // v2 after previous operation
+                local.add2[i + 8].value,                             // v2 after previous operation
                 local.xor[i + 20],
                 local.shard,
                 &local.channel,
@@ -282,23 +261,22 @@ where
 
             // 4x
             // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-            Add4Operation::<AB::F>::eval(
+            Add3Operation::<AB::F>::eval(
                 builder,
-                local.add[i + 16].value,          // v0 after 3x
+                local.add3[i + 8].value,          // v0 after 3x
                 local.rotate_right[i + 20].value, // v1 after 3x
                 *local.b[i + 12].value(),         // m4
-                *local.b[i + 16].value(),         // zero1
                 local.shard,
                 local.channel,
                 local.is_real,
-                local.add[i + 24],
+                local.add3[i + 12],
             );
 
             // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i + 16].value, // v3 after 3x
-                local.add[i + 24].value,          // v0 after previous operation
+                local.add3[i + 12].value,         // v0 after previous operation
                 local.xor[i + 24],
                 local.shard,
                 &local.channel,
@@ -315,23 +293,21 @@ where
             );
 
             // v[2] = v[2].wrapping_add(v[3]);
-            Add4Operation::<AB::F>::eval(
+            AddOperation::<AB::F>::eval(
                 builder,
-                local.add[i + 20].value,          // v2 after 3x
+                local.add2[i + 8].value,          // v2 after 3x
                 local.rotate_right[i + 24].value, // v3 after previous operation
-                *local.b[i + 16].value(),         // zero1
-                *local.b[i + 20].value(),         // zero2
+                local.add2[i + 12],
                 local.shard,
                 local.channel,
-                local.is_real,
-                local.add[i + 28],
+                local.is_real.into(),
             );
 
             // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
             XorOperation::<AB::F>::eval(
                 builder,
                 local.rotate_right[i + 20].value, // v1 after 3x
-                local.add[i + 28].value,          // v2 after previous operation
+                local.add2[i + 12].value,         // v2 after previous operation
                 local.xor[i + 28],
                 local.shard,
                 &local.channel,
diff --git a/core/src/syscall/precompiles/blake2s/columns.rs b/core/src/syscall/precompiles/blake2s/columns.rs
index a684fd9f0..1d17a2108 100644
--- a/core/src/syscall/precompiles/blake2s/columns.rs
+++ b/core/src/syscall/precompiles/blake2s/columns.rs
@@ -1,5 +1,5 @@
 use crate::memory::{MemoryReadCols, MemoryWriteCols};
-use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation};
+use crate::operations::{Add3Operation, AddOperation, FixedRotateRightOperation, XorOperation};
 use sphinx_derive::AlignedBorrow;
 
 #[derive(Debug, Clone, AlignedBorrow)]
@@ -27,13 +27,12 @@ pub struct Blake2sRoundCols<T> {
     ///    m1[0] || m1[1] || m1[2] || m1[3] ||
     ///    m2[0] || m2[1] || m2[2] || m2[3] ||
     ///    m3[0] || m3[1] || m3[2] || m3[3] ||
-    ///    0 || 0 || 0 || 0 ||
-    ///    0 || 0 || 0 || 0 ||
     ///
     pub a: [MemoryWriteCols<T>; 16],
-    pub b: [MemoryReadCols<T>; 24],
+    pub b: [MemoryReadCols<T>; 16],
 
-    pub add: [Add4Operation<T>; 32],
+    pub add3: [Add3Operation<T>; 16],
+    pub add2: [AddOperation<T>; 16],
     pub xor: [XorOperation<T>; 32],
     pub rotate_right: [FixedRotateRightOperation<T>; 32],
 }
diff --git a/core/src/syscall/precompiles/blake2s/execute.rs b/core/src/syscall/precompiles/blake2s/execute.rs
index c4e7b5d0d..6a568a1a5 100644
--- a/core/src/syscall/precompiles/blake2s/execute.rs
+++ b/core/src/syscall/precompiles/blake2s/execute.rs
@@ -16,7 +16,7 @@ impl Syscall for Blake2sRoundChip {
         let mut a = ctx.slice_unsafe(a_ptr, 16);
         let mut a_clone = a.clone();
 
-        let (b_reads, b) = ctx.mr_slice(b_ptr, 24);
+        let (b_reads, b) = ctx.mr_slice(b_ptr, 16);
 
         // 1x (m0, R1, R2)
         // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m1)
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index db178b42f..ca52c776d 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -145,10 +145,7 @@ fn round(v: &mut [[u32; 4]], m: [u32; 16], s: [usize; 16]) {
 
 pub fn blake2s_round(v: &mut [u32], m: &[u32]) {
     assert_eq!(v.len(), 16);
-    assert_eq!(m.len(), 24);
-    for item in m[16..24].iter() {
-        assert_eq!(*item, 0u32);
-    }
+    assert_eq!(m.len(), 16);
 
     let r1 = 16;
     let r2 = 12;
@@ -186,7 +183,7 @@ mod tests {
     use crate::Program;
     use rand::Rng;
 
-    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 16], b: [u32; 24]) -> Program {
+    fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 16], b: [u32; 16]) -> Program {
         let mut instructions = vec![];
         // memory write a
         for (index, word) in a.into_iter().enumerate() {
@@ -240,10 +237,7 @@ mod tests {
 
         let a = rand::thread_rng().gen::<[u32; 16]>();
         let mut a_clone = a;
-        let mut b = rand::thread_rng().gen::<[u32; 24]>();
-        for item in b[0..24].iter_mut() {
-            *item = 0;
-        }
+        let b = rand::thread_rng().gen::<[u32; 16]>();
 
         blake2s_round(&mut a_clone, &b);
 
diff --git a/core/src/syscall/precompiles/blake2s/trace.rs b/core/src/syscall/precompiles/blake2s/trace.rs
index d710f0fd8..8159d8c73 100644
--- a/core/src/syscall/precompiles/blake2s/trace.rs
+++ b/core/src/syscall/precompiles/blake2s/trace.rs
@@ -56,12 +56,6 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
             }
 
-            // populate extra-zeroes
-            // TODO: replace Add4 with Add3 operation and avoid this
-            for i in 16..24usize {
-                cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events);
-            }
-
             let mut v0_outer = [0u32; 4];
             let mut v1_outer = [0u32; 4];
             let mut v2_outer = [0u32; 4];
@@ -74,13 +68,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 let v2 = event.a_reads_writes[i + 8].prev_value;
                 let v3 = event.a_reads_writes[i + 12].prev_value;
                 let m1 = event.b_reads[i].value;
-                let zero1 = event.b_reads[i + 16].value;
-                let zero2 = event.b_reads[i + 20].value;
-                assert_eq!(zero1, 0);
-                assert_eq!(zero2, 0);
 
                 // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-                let v0_new = cols.add[i].populate(output, shard, event.channel, v0, v1, m1, zero1);
+                let v0_new = cols.add3[i].populate(output, shard, event.channel, v0, v1, m1);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
                 let temp = cols.xor[i].populate(output, shard, event.channel, v3, v0_new);
@@ -88,15 +78,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                     cols.rotate_right[i].populate(output, shard, event.channel, temp, R_1 as usize);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                let v2_new = cols.add[i + 4].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    v2,
-                    v3_new,
-                    zero1,
-                    zero2,
-                );
+                let v2_new = cols.add2[i].populate(output, shard, event.channel, v2, v3_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
                 let temp = cols.xor[i + 4].populate(output, shard, event.channel, v1, v2_new);
@@ -121,12 +103,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 let v2 = v2_outer[i];
                 let v3 = v3_outer[i];
                 let m2 = event.b_reads[i + 4].value;
-                let zero1 = event.b_reads[i + 16].value;
-                let zero2 = event.b_reads[i + 20].value;
 
                 // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
-                let v0_new =
-                    cols.add[i + 8].populate(output, shard, event.channel, v0, v1, m2, zero1);
+                let v0_new = cols.add3[i + 4].populate(output, shard, event.channel, v0, v1, m2);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
                 let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0_new);
@@ -139,15 +118,7 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 );
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                let v2_new = cols.add[i + 4 + 8].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    v2,
-                    v3_new,
-                    zero1,
-                    zero2,
-                );
+                let v2_new = cols.add2[i + 4].populate(output, shard, event.channel, v2, v3_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
                 let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2_new);
@@ -191,15 +162,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 let v2 = v2_outer[i];
                 let v3 = v3_outer[i];
                 let m3 = event.b_reads[i + 8].value;
-                let zero1 = event.b_reads[i + 16].value;
-                let zero2 = event.b_reads[i + 20].value;
-                assert_eq!(zero1, 0);
-                assert_eq!(zero2, 0);
 
                 // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le());
-                let v0_new =
-                    cols.add[i + 16].populate(output, shard, event.channel, v0, v1, m3, zero1);
-                assert_eq!(v0 + v1 + m3 + zero1, v0_new);
+                let v0_new = cols.add3[i + 8].populate(output, shard, event.channel, v0, v1, m3);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd);
                 let temp = cols.xor[i + 16].populate(output, shard, event.channel, v3, v0_new);
@@ -210,19 +175,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                     temp,
                     R_1 as usize,
                 );
-                assert_eq!((v3 ^ v0_new).rotate_right(R_1), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                let v2_new = cols.add[i + 16 + 4].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    v2,
-                    v3_new,
-                    zero1,
-                    zero2,
-                );
-                assert_eq!(v2 + v3_new + zero1 + zero2, v2_new);
+                let v2_new = cols.add2[i + 8].populate(output, shard, event.channel, v2, v3_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb);
                 let temp = cols.xor[i + 16 + 4].populate(output, shard, event.channel, v1, v2_new);
@@ -233,7 +188,6 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                     temp,
                     R_2 as usize,
                 );
-                assert_eq!((v1 ^ v2_new).rotate_right(R_2), v1_new);
 
                 v0_outer[i] = v0_new;
                 v1_outer[i] = v1_new;
@@ -248,15 +202,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                 let v2 = v2_outer[i];
                 let v3 = v3_outer[i];
                 let m4 = event.b_reads[i + 12].value;
-                let zero1 = event.b_reads[i + 16].value;
-                let zero2 = event.b_reads[i + 20].value;
-                assert_eq!(zero1, 0);
-                assert_eq!(zero2, 0);
 
                 // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2)
-                let v0_new =
-                    cols.add[i + 16 + 8].populate(output, shard, event.channel, v0, v1, m4, zero1);
-                assert_eq!(v0 + v1 + m4 + zero1, v0_new);
+                let v0_new = cols.add3[i + 12].populate(output, shard, event.channel, v0, v1, m4);
 
                 // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3)
                 let temp = cols.xor[i + 16 + 8].populate(output, shard, event.channel, v3, v0_new);
@@ -267,18 +215,9 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
                     temp,
                     R_3 as usize,
                 );
-                assert_eq!((v3 ^ v0_new).rotate_right(R_3), v3_new);
 
                 // v[2] = v[2].wrapping_add(v[3]);
-                let v2_new = cols.add[i + 16 + 4 + 8].populate(
-                    output,
-                    shard,
-                    event.channel,
-                    v2,
-                    v3_new,
-                    zero1,
-                    zero2,
-                );
+                let v2_new = cols.add2[i + 12].populate(output, shard, event.channel, v2, v3_new);
 
                 // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4)
                 let temp =
diff --git a/tests/blake2s-round/Cargo.lock b/tests/blake2s-round/Cargo.lock
index 7efd0650c..e2a3cc14e 100644
--- a/tests/blake2s-round/Cargo.lock
+++ b/tests/blake2s-round/Cargo.lock
@@ -42,7 +42,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "blake2s-quarter_round-2x-test"
+name = "blake2s-round-test"
 version = "0.1.0"
 dependencies = [
  "sphinx-zkvm",
diff --git a/tests/blake2s-round/Cargo.toml b/tests/blake2s-round/Cargo.toml
index 188c60950..98d23e472 100644
--- a/tests/blake2s-round/Cargo.toml
+++ b/tests/blake2s-round/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace]
 [package]
-name = "blake2s-quarter_round-2x-test"
+name = "blake2s-round-test"
 version = "0.1.0"
 edition = "2021"
 
diff --git a/tests/blake2s-round/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-round/elf/riscv32im-succinct-zkvm-elf
index d20fc7e4394539b95ec58368a5f2c68ef66e49f8..fef04f7e418a7cf1d0be9ce6d562ef6bd302e8f0 100755
GIT binary patch
delta 36
scmZ3pk#WsN#tq86tlyQ@1UV*a@J?rBnS6j(nUzDBk&$!r3*IAM0Mzsf!vFvP

delta 36
scmZ3pk#WsN#tq86tY4MY1i2<_@J?rBn|y#*nUzbJk&%1z3*IAM0M#rC$p8QV

diff --git a/tests/blake2s-round/src/main.rs b/tests/blake2s-round/src/main.rs
index c67c53605..1fec17136 100644
--- a/tests/blake2s-round/src/main.rs
+++ b/tests/blake2s-round/src/main.rs
@@ -9,7 +9,7 @@ pub fn main() {
         0x5be0cd19, 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
         0xe07c2654, 0x5be0cd19
     ];
-    let b: [u32; 24] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    let b: [u32; 16] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
 
     syscall_blake2s_round(a.as_mut_ptr(), b.as_ptr());
 }

From 430087acd357f09b56ad41e56caf5aa46ca949fc Mon Sep 17 00:00:00 2001
From: Artem Storozhuk <storojs72@gmail.com>
Date: Tue, 24 Sep 2024 18:15:55 +0300
Subject: [PATCH 30/30] chore: Address feedback

---
 Cargo.lock                                    | 54 +++++++++----------
 Cargo.toml                                    |  2 +-
 core/src/stark/air.rs                         |  5 +-
 core/src/syscall/precompiles/blake2s/air.rs   |  2 -
 .../syscall/precompiles/blake2s/columns.rs    |  2 -
 core/src/syscall/precompiles/blake2s/mod.rs   | 20 -------
 core/src/syscall/precompiles/blake2s/trace.rs |  4 --
 core/src/utils/prove.rs                       | 10 ++--
 zkvm/precompiles/src/lib.rs                   | 10 +---
 9 files changed, 37 insertions(+), 72 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index fcf5f2030..6e41ea19c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -466,9 +466,9 @@ dependencies = [
 
 [[package]]
 name = "axum-core"
-version = "0.4.3"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a15c63fd72d41492dc4f497196f5da1fb04fb7529e631d73630d1b491e47a2e3"
+checksum = "5e6b8ba012a258d63c9adfa28b9ddcf66149da6f986c5b5452e629d5ee64bf00"
 dependencies = [
  "async-trait",
  "bytes",
@@ -479,7 +479,7 @@ dependencies = [
  "mime",
  "pin-project-lite",
  "rustversion",
- "sync_wrapper 0.1.2",
+ "sync_wrapper 1.0.1",
  "tower-layer",
  "tower-service",
  "tracing",
@@ -848,9 +848,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.17"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e5a21b8495e732f1b3c364c9949b201ca7bae518c502c80256c96ad79eaf6ac"
+checksum = "b0956a43b323ac1afaffc053ed5c4b7c1f1800bacd1683c353aabbb752515dd3"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -858,9 +858,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.17"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cf2dd12af7a047ad9d6da2b6b249759a22a7abc0f474c1dae1777afa4b21a73"
+checksum = "4d72166dd41634086d5803a47eb71ae740e61d84709c36f3c34110173db3961b"
 dependencies = [
  "anstream",
  "anstyle",
@@ -870,9 +870,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.13"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501d359d5f3dcaf6ecdeee48833ae73ec6e42723a1e52419c79abf9507eec0a0"
+checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -2457,9 +2457,9 @@ dependencies = [
 
 [[package]]
 name = "k256"
-version = "0.13.3"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b"
+checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b"
 dependencies = [
  "cfg-if",
  "ecdsa",
@@ -2505,9 +2505,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.158"
+version = "0.2.159"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5"
 
 [[package]]
 name = "libgit2-sys"
@@ -3254,9 +3254,9 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.7.12"
+version = "2.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c73c26c01b8c87956cea613c907c9d6ecffd8d18a2a5908e5de0adfaa185cea"
+checksum = "fdbef9d1d47087a895abd220ed25eb4ad973a5e26f6a4367b038c25e28dfc2d9"
 dependencies = [
  "memchr",
  "thiserror",
@@ -3317,9 +3317,9 @@ dependencies = [
 
 [[package]]
 name = "pkg-config"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
 
 [[package]]
 name = "plotters"
@@ -3351,9 +3351,9 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
+checksum = "d30538d42559de6b034bc76fd6dd4c38961b1ee5c6c56e3808c50128fdbc22ce"
 
 [[package]]
 name = "powerfmt"
@@ -4948,18 +4948,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.63"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
+checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.63"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
+checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5350,15 +5350,15 @@ dependencies = [
 
 [[package]]
 name = "unicode-width"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
 name = "unicode-xid"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "229730647fbc343e3a80e463c1db7f78f3855d3f3739bee0dda773c9a037c90a"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "untrusted"
diff --git a/Cargo.toml b/Cargo.toml
index c8a8085d6..274f79a71 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -78,7 +78,7 @@ getrandom = "=0.2.14" # 0.2.15 depends on yanked libc 0.2.154
 hashbrown = { version = "0.14.5", features = ["serde"] }
 hex = "0.4.3"
 home = "0.5.9"
-hybrid-array = "0.2.0-rc.9"
+hybrid-array = "0.2.0-rc"
 indicatif = "0.17.8"
 itertools = "0.12.1"
 k256 = "0.13.3"
diff --git a/core/src/stark/air.rs b/core/src/stark/air.rs
index af094bb27..31fe0b1e0 100644
--- a/core/src/stark/air.rs
+++ b/core/src/stark/air.rs
@@ -161,6 +161,9 @@ impl<F: PrimeField32> RiscvAir<F> {
         chips.push(RiscvAir::Bls12381Fp2Op(bls12381_fp2_op));
         let bls12381_g1_decompress = Bls12381G1DecompressChip::new();
         chips.push(RiscvAir::Bls12381G1Decompress(bls12381_g1_decompress));
+        let blake_2s_round = Blake2sRoundChip::new();
+        chips.push(RiscvAir::Blake2sRound(blake_2s_round));
+
         let div_rem = DivRemChip;
         chips.push(RiscvAir::DivRem(div_rem));
 
@@ -184,8 +187,6 @@ impl<F: PrimeField32> RiscvAir<F> {
         chips.push(RiscvAir::ProgramMemory(program_memory_init));
         let byte = ByteChip::default();
         chips.push(RiscvAir::ByteLookup(byte));
-        let blake_2s_round = Blake2sRoundChip::new();
-        chips.push(RiscvAir::Blake2sRound(blake_2s_round));
 
         chips
     }
diff --git a/core/src/syscall/precompiles/blake2s/air.rs b/core/src/syscall/precompiles/blake2s/air.rs
index d054431dc..8b519501e 100644
--- a/core/src/syscall/precompiles/blake2s/air.rs
+++ b/core/src/syscall/precompiles/blake2s/air.rs
@@ -191,8 +191,6 @@ where
             );
         }
 
-        self.constrain_shuffled_indices(builder, &local.shuffled_indices, local.is_real);
-
         for i in 0..4usize {
             // 3x
 
diff --git a/core/src/syscall/precompiles/blake2s/columns.rs b/core/src/syscall/precompiles/blake2s/columns.rs
index 1d17a2108..897f41598 100644
--- a/core/src/syscall/precompiles/blake2s/columns.rs
+++ b/core/src/syscall/precompiles/blake2s/columns.rs
@@ -15,8 +15,6 @@ pub struct Blake2sRoundCols<T> {
     pub a_ptr: T,
     pub b_ptr: T,
 
-    pub shuffled_indices: [T; 16],
-
     /// Memory layout:
     /// a: v0[0] || v0[1] || v0[2] || v0[3] ||
     ///    v1[0] || v1[1] || v1[2] || v1[3] ||
diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs
index ca52c776d..d4beb98fa 100644
--- a/core/src/syscall/precompiles/blake2s/mod.rs
+++ b/core/src/syscall/precompiles/blake2s/mod.rs
@@ -6,9 +6,6 @@ mod trace;
 pub use columns::*;
 
 use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};
-use crate::stark::SphinxAirBuilder;
-use p3_air::AirBuilder;
-use p3_field::AbstractField;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -31,23 +28,6 @@ impl Blake2sRoundChip {
     pub fn new() -> Self {
         Blake2sRoundChip
     }
-    pub fn constrain_shuffled_indices<AB: SphinxAirBuilder>(
-        &self,
-        builder: &mut AB,
-        indices: &[AB::Var],
-        is_real: AB::Var,
-    ) {
-        for index in 0..4 {
-            builder
-                .when(is_real)
-                .assert_eq(indices[index], AB::F::from_canonical_usize(0));
-        }
-        for index in 4..indices.len() {
-            builder
-                .when(is_real)
-                .assert_eq(indices[index], AB::F::from_canonical_usize(1));
-        }
-    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/core/src/syscall/precompiles/blake2s/trace.rs b/core/src/syscall/precompiles/blake2s/trace.rs
index 8159d8c73..3061fb669 100644
--- a/core/src/syscall/precompiles/blake2s/trace.rs
+++ b/core/src/syscall/precompiles/blake2s/trace.rs
@@ -153,10 +153,6 @@ impl<F: PrimeField32> MachineAir<F> for Blake2sRoundChip {
 
             // 3x (m2, R1, R2)
             for i in 0..4usize {
-                cols.shuffled_indices[i + 4] = F::from_canonical_u32(1);
-                cols.shuffled_indices[i + 8] = F::from_canonical_u32(1);
-                cols.shuffled_indices[i + 12] = F::from_canonical_u32(1);
-
                 let v0 = v0_outer[i];
                 let v1 = v1_outer[i];
                 let v2 = v2_outer[i];
diff --git a/core/src/utils/prove.rs b/core/src/utils/prove.rs
index 1f223cdcf..dee783732 100644
--- a/core/src/utils/prove.rs
+++ b/core/src/utils/prove.rs
@@ -356,11 +356,11 @@ where
     OpeningProof<SC>: Send + Sync,
     ShardMainData<SC>: Serialize + DeserializeOwned,
 {
-    //#[cfg(debug_assertions)]
-    //{
-    let record_clone = record.clone();
-    machine.debug_constraints(pk, record_clone);
-    //}
+    #[cfg(debug_assertions)]
+    {
+        let record_clone = record.clone();
+        machine.debug_constraints(pk, record_clone);
+    }
     let stats = record.stats().clone();
     let cycles = stats.get("cpu_events").unwrap();
 
diff --git a/zkvm/precompiles/src/lib.rs b/zkvm/precompiles/src/lib.rs
index 1c627089a..a5a1d7aa9 100644
--- a/zkvm/precompiles/src/lib.rs
+++ b/zkvm/precompiles/src/lib.rs
@@ -47,13 +47,5 @@ extern "C" {
     pub fn sys_alloc_aligned(bytes: usize, align: usize) -> *mut u8;
     pub fn syscall_bls12381_g2_add(p: *mut u32, q: *const u32);
     pub fn syscall_bls12381_g2_double(p: *mut u32);
-    pub fn syscall_blake2s_xor_rotate_16(w: *mut u32);
-
-    pub fn syscall_blake2s_add_2(left: *mut u32, right: *const u32);
-    pub fn syscall_blake2s_add_3(left: *mut u32, right: *const u32);
-    pub fn syscall_blake2s_xor_rotate_right_16(left: *mut u32, right: *const u32);
-    pub fn syscall_blake2s_xor_rotate_right_12(left: *mut u32, right: *const u32);
-    pub fn syscall_blake2s_xor_rotate_right_8(left: *mut u32, right: *const u32);
-    pub fn syscall_blake2s_xor_rotate_right_7(left: *mut u32, right: *const u32);
-    pub fn syscall_blake2s_quarter_round(left: *mut u32, right: *const u32);
+    pub fn syscall_blake2s_round(left: *mut u32, right: *const u32);
 }