From e6d0275f2addac87ef6f9afdae6a661b4a795db6 Mon Sep 17 00:00:00 2001
From: Nicholas Ward <npward@berkeley.edu>
Date: Wed, 1 Jun 2022 09:20:39 -0700
Subject: [PATCH] fmt

---
 evm/src/all_stark.rs           |  8 ++++----
 evm/src/keccak/keccak_stark.rs | 36 +++++++++++++++++-----------------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/evm/src/all_stark.rs b/evm/src/all_stark.rs
index a943e99c..00344646 100644
--- a/evm/src/all_stark.rs
+++ b/evm/src/all_stark.rs
@@ -63,7 +63,7 @@ mod tests {
     use crate::cpu;
     use crate::cpu::cpu_stark::CpuStark;
     use crate::cross_table_lookup::CrossTableLookup;
-    use crate::keccak::keccak_stark::{KeccakStark, NUM_ROUNDS, INPUT_LIMBS};
+    use crate::keccak::keccak_stark::{KeccakStark, INPUT_LIMBS, NUM_ROUNDS};
     use crate::proof::AllProof;
     use crate::prover::prove;
     use crate::recursive_verifier::{
@@ -89,7 +89,7 @@ mod tests {
         let keccak_rows = (NUM_ROUNDS + 1).next_power_of_two();
 
         let mut cpu_trace = vec![PolynomialValues::<F>::zero(cpu_rows); 10];
-        
+
         let mut rng = ChaCha8Rng::seed_from_u64(0x6feb51b7ec230f25);
 
         let num_inpts = 1;
@@ -97,10 +97,10 @@ mod tests {
             .map(|_| [0u64; INPUT_LIMBS].map(|_| rng.gen()))
             .collect_vec();
         let keccak_trace = keccak_stark.generate_trace(keccak_inputs);
-        
+
         let vs0: Vec<_> = keccak_trace[3].values[..].into();
         let vs1: Vec<_> = keccak_trace[5].values[..].into();
-        
+
         let start = thread_rng().gen_range(0..cpu_rows - keccak_rows);
 
         let default = vec![F::ONE; 2];
diff --git a/evm/src/keccak/keccak_stark.rs b/evm/src/keccak/keccak_stark.rs
index 3fbc7b94..a6b0b162 100644
--- a/evm/src/keccak/keccak_stark.rs
+++ b/evm/src/keccak/keccak_stark.rs
@@ -39,7 +39,10 @@ pub struct KeccakStark<F, const D: usize> {
 impl<F: RichField + Extendable<D>, const D: usize> KeccakStark<F, D> {
     /// Generate the rows of the trace. Note that this does not generate the permuted columns used
     /// in our lookup arguments, as those are computed after transposing to column-wise form.
-    pub(crate) fn generate_trace_rows(&self, inputs: Vec<[u64; INPUT_LIMBS]>) -> Vec<[F; NUM_REGISTERS]> {
+    pub(crate) fn generate_trace_rows(
+        &self,
+        inputs: Vec<[u64; INPUT_LIMBS]>,
+    ) -> Vec<[F; NUM_REGISTERS]> {
         let num_rows = (inputs.len() * NUM_ROUNDS).next_power_of_two();
         info!("{} rows", num_rows);
         let mut rows = Vec::with_capacity(num_rows);
@@ -57,10 +60,7 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakStark<F, D> {
         rows
     }
 
-    fn generate_trace_rows_for_perm(
-        &self,
-        input: [u64; INPUT_LIMBS],
-    ) -> Vec<[F; NUM_REGISTERS]> {
+    fn generate_trace_rows_for_perm(&self, input: [u64; INPUT_LIMBS]) -> Vec<[F; NUM_REGISTERS]> {
         let mut rows = vec![[F::ZERO; NUM_REGISTERS]; NUM_ROUNDS];
 
         for x in 0..5 {
@@ -132,17 +132,17 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakStark<F, D> {
         for x in 0..5 {
             for y in 0..5 {
                 // let get_bit = |z| {
-                    
+
                 //     // xor([
                 //     //     row[reg_b(x, y, z)],
                 //     //     andn(row[reg_b((x + 1) % 5, y, z)], row[reg_b((x + 2) % 5, y, z)]),
                 //     // ])
                 // };
 
-                let lo = F::ZERO;//row[reg_b(x, y, 0)];
-                // let hi = (32..64)
-                //     .rev()
-                //     .fold(F::ZERO, |acc, z| acc.double() + get_bit(z));
+                let lo = F::ZERO; //row[reg_b(x, y, 0)];
+                                  // let hi = (32..64)
+                                  //     .rev()
+                                  //     .fold(F::ZERO, |acc, z| acc.double() + get_bit(z));
 
                 let reg_lo = reg_a_prime_prime(x, y);
                 let reg_hi = reg_lo + 1;
@@ -241,11 +241,11 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for KeccakStark<F
             for y in 0..5 {
                 let get_bit = |z| {
                     // xor_gen(
-                        vars.local_values[reg_b(x, y, z)]
-                        // andn_gen(
-                        //     vars.local_values[reg_b((x + 1) % 5, y, z)],
-                        //     vars.local_values[reg_b((x + 2) % 5, y, z)],
-                        // ),
+                    vars.local_values[reg_b(x, y, z)]
+                    // andn_gen(
+                    //     vars.local_values[reg_b((x + 1) % 5, y, z)],
+                    //     vars.local_values[reg_b((x + 2) % 5, y, z)],
+                    // ),
                     // )
                 };
 
@@ -253,9 +253,9 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for KeccakStark<F
                 let reg_hi = reg_lo + 1;
                 let lo = vars.local_values[reg_lo];
                 // let hi = vars.local_values[reg_hi];
-                let computed_lo = P::ZEROS;// vars.local_values[reg_b(x, y, 0)];//(0..32)
-                    // .rev()
-                    // .fold(P::ZEROS, |acc, z| acc.doubles() + get_bit(z));
+                let computed_lo = P::ZEROS; // vars.local_values[reg_b(x, y, 0)];//(0..32)
+                                            // .rev()
+                                            // .fold(P::ZEROS, |acc, z| acc.doubles() + get_bit(z));
                 let computed_hi = (32..64)
                     .rev()
                     .fold(P::ZEROS, |acc, z| acc.doubles() + get_bit(z));