From 75ad055f40cc953da66e942752ab4127e4c4cb18 Mon Sep 17 00:00:00 2001 From: wborgeaud Date: Fri, 13 Aug 2021 14:28:05 +0200 Subject: [PATCH] First try --- src/gadgets/arithmetic_extension.rs | 135 ++++++++++++++++++++- src/gates/arithmetic.rs | 175 +++++++++++++++++----------- src/iop/generator.rs | 8 +- src/plonk/circuit_builder.rs | 3 + src/plonk/circuit_data.rs | 4 +- src/plonk/recursive_verifier.rs | 7 +- src/plonk/vanishing_poly.rs | 3 + src/util/reducing.rs | 27 ++++- 8 files changed, 278 insertions(+), 84 deletions(-) diff --git a/src/gadgets/arithmetic_extension.rs b/src/gadgets/arithmetic_extension.rs index 8b7c11e3..b76a2482 100644 --- a/src/gadgets/arithmetic_extension.rs +++ b/src/gadgets/arithmetic_extension.rs @@ -9,11 +9,75 @@ use crate::field::field_types::Field; use crate::gates::arithmetic::ArithmeticExtensionGate; use crate::iop::generator::{GeneratedValues, SimpleGenerator}; use crate::iop::target::Target; +use crate::iop::wire::Wire; use crate::iop::witness::PartialWitness; use crate::plonk::circuit_builder::CircuitBuilder; use crate::util::bits_u64; impl, const D: usize> CircuitBuilder { + pub fn yo( + &mut self, + gate: usize, + first_multiplicand_0: ExtensionTarget, + first_multiplicand_1: ExtensionTarget, + first_addend: ExtensionTarget, + second_multiplicand_0: ExtensionTarget, + second_multiplicand_1: ExtensionTarget, + second_addend: ExtensionTarget, + ) -> (ExtensionTarget, ExtensionTarget) { + // for et in &mut [ + // first_multiplicand_0, + // first_multiplicand_1, + // first_addend, + // second_multiplicand_0, + // second_multiplicand_1, + // second_addend, + // ] { + // for t in &mut et.0 { + // if let Target::Wire(Wire { gate: g, input }) = t { + // if *g > gate { + // *g = gate; + // *input += 8 * D; + // dbg!(*g, *t); + // } + // } + // } + // } + let wire_third_multiplicand_0 = ExtensionTarget::from_range( + gate, + ArithmeticExtensionGate::::wires_third_multiplicand_0(), + ); + let wire_third_multiplicand_1 = ExtensionTarget::from_range( + gate, + ArithmeticExtensionGate::::wires_third_multiplicand_1(), + ); + let wire_third_addend = + ExtensionTarget::from_range(gate, ArithmeticExtensionGate::::wires_third_addend()); + let wire_fourth_multiplicand_0 = ExtensionTarget::from_range( + gate, + ArithmeticExtensionGate::::wires_fourth_multiplicand_0(), + ); + let wire_fourth_multiplicand_1 = ExtensionTarget::from_range( + gate, + ArithmeticExtensionGate::::wires_fourth_multiplicand_1(), + ); + let wire_fourth_addend = + ExtensionTarget::from_range(gate, ArithmeticExtensionGate::::wires_fourth_addend()); + let wire_third_output = + ExtensionTarget::from_range(gate, ArithmeticExtensionGate::::wires_third_output()); + let wire_fourth_output = + ExtensionTarget::from_range(gate, ArithmeticExtensionGate::::wires_fourth_output()); + + self.route_extension(first_multiplicand_0, wire_third_multiplicand_0); + self.route_extension(first_multiplicand_1, wire_third_multiplicand_1); + self.route_extension(first_addend, wire_third_addend); + self.route_extension(second_multiplicand_0, wire_fourth_multiplicand_0); + self.route_extension(second_multiplicand_1, wire_fourth_multiplicand_1); + self.route_extension(second_addend, wire_fourth_addend); + self.free_arithmetic = None; + + (wire_third_output, wire_fourth_output) + } pub fn double_arithmetic_extension( &mut self, const_0: F, @@ -25,8 +89,22 @@ impl, const D: usize> CircuitBuilder { second_multiplicand_1: ExtensionTarget, second_addend: ExtensionTarget, ) -> (ExtensionTarget, ExtensionTarget) { - let gate = self.add_gate(ArithmeticExtensionGate, vec![const_0, const_1]); + if let Some((g, c_0, c_1)) = self.free_arithmetic { + if g == self.num_gates() - 1 && c_0 == const_0 && c_1 == const_1 { + return self.yo( + g, + first_multiplicand_0, + first_multiplicand_1, + first_addend, + second_multiplicand_0, + second_multiplicand_1, + second_addend, + ); + } + } + let gate = self.add_gate(ArithmeticExtensionGate, vec![const_0, const_1]); + self.free_arithmetic = Some((gate, const_0, const_1)); let wire_first_multiplicand_0 = ExtensionTarget::from_range( gate, ArithmeticExtensionGate::::wires_first_multiplicand_0(), @@ -175,11 +253,27 @@ impl, const D: usize> CircuitBuilder { for chunk in pairs.chunks_exact(2) { let (a0, b0) = chunk[0]; let (a1, b1) = chunk[1]; - let gate = self.num_gates(); - let first_out = ExtensionTarget::from_range( - gate, - ArithmeticExtensionGate::::wires_first_output(), - ); + let (gate, range) = if let Some((g, c_0, c_1)) = self.free_arithmetic { + if g == self.num_gates() - 1 && c_0 == constant && c_1 == F::ONE { + (g, ArithmeticExtensionGate::::wires_third_output()) + } else { + ( + self.num_gates(), + ArithmeticExtensionGate::::wires_first_output(), + ) + } + } else { + ( + self.num_gates(), + ArithmeticExtensionGate::::wires_first_output(), + ) + }; + let first_out = ExtensionTarget::from_range(gate, range); + // let gate = self.num_gates(); + // let first_out = ExtensionTarget::from_range( + // gate, + // ArithmeticExtensionGate::::wires_first_output(), + // ); acc = self .double_arithmetic_extension(constant, F::ONE, a0, b0, acc, a1, b1, first_out) .1; @@ -706,6 +800,35 @@ mod tests { verify(proof, &data.verifier_only, &data.common) } + #[test] + fn test_mul() -> Result<()> { + type F = CrandallField; + type FF = QuarticCrandallField; + const D: usize = 4; + + let config = CircuitConfig::large_config(); + + let pw = PartialWitness::new(config.num_wires); + let mut builder = CircuitBuilder::::new(config); + + let x = FF::ONE; + let y = FF::TWO; + let z = x * y; + let xt = builder.constant_extension(x); + let yt = builder.constant_extension(y); + let zt = builder.constant_extension(z); + let comp_zt = builder.mul_extension(xt, yt); + dbg!(comp_zt); + builder.add_marked(zt.into(), "yo"); + builder.add_marked(comp_zt.into(), "ya"); + builder.assert_equal_extension(zt, comp_zt); + + let data = builder.build(); + let proof = data.prove(pw)?; + + verify(proof, &data.verifier_only, &data.common) + } + #[test] fn test_div_extension() -> Result<()> { type F = CrandallField; diff --git a/src/gates/arithmetic.rs b/src/gates/arithmetic.rs index 81c9bc9a..7c780671 100644 --- a/src/gates/arithmetic.rs +++ b/src/gates/arithmetic.rs @@ -27,6 +27,7 @@ impl ArithmeticExtensionGate { pub fn wires_first_output() -> Range { 3 * D..4 * D } + pub fn wires_second_multiplicand_0() -> Range { 4 * D..5 * D } @@ -39,6 +40,32 @@ impl ArithmeticExtensionGate { pub fn wires_second_output() -> Range { 7 * D..8 * D } + + pub fn wires_third_multiplicand_0() -> Range { + 8 * D..9 * D + } + pub fn wires_third_multiplicand_1() -> Range { + 9 * D..10 * D + } + pub fn wires_third_addend() -> Range { + 10 * D..11 * D + } + pub fn wires_third_output() -> Range { + 11 * D..12 * D + } + + pub fn wires_fourth_multiplicand_0() -> Range { + 12 * D..13 * D + } + pub fn wires_fourth_multiplicand_1() -> Range { + 13 * D..14 * D + } + pub fn wires_fourth_addend() -> Range { + 14 * D..15 * D + } + pub fn wires_fourth_output() -> Range { + 15 * D..16 * D + } } impl, const D: usize> Gate for ArithmeticExtensionGate { @@ -56,18 +83,32 @@ impl, const D: usize> Gate for ArithmeticExtensionGate let second_multiplicand_0 = vars.get_local_ext_algebra(Self::wires_second_multiplicand_0()); let second_multiplicand_1 = vars.get_local_ext_algebra(Self::wires_second_multiplicand_1()); let second_addend = vars.get_local_ext_algebra(Self::wires_second_addend()); + let third_multiplicand_0 = vars.get_local_ext_algebra(Self::wires_third_multiplicand_0()); + let third_multiplicand_1 = vars.get_local_ext_algebra(Self::wires_third_multiplicand_1()); + let third_addend = vars.get_local_ext_algebra(Self::wires_third_addend()); + let fourth_multiplicand_0 = vars.get_local_ext_algebra(Self::wires_fourth_multiplicand_0()); + let fourth_multiplicand_1 = vars.get_local_ext_algebra(Self::wires_fourth_multiplicand_1()); + let fourth_addend = vars.get_local_ext_algebra(Self::wires_fourth_addend()); let first_output = vars.get_local_ext_algebra(Self::wires_first_output()); let second_output = vars.get_local_ext_algebra(Self::wires_second_output()); + let third_output = vars.get_local_ext_algebra(Self::wires_third_output()); + let fourth_output = vars.get_local_ext_algebra(Self::wires_fourth_output()); let first_computed_output = first_multiplicand_0 * first_multiplicand_1 * const_0.into() + first_addend * const_1.into(); let second_computed_output = second_multiplicand_0 * second_multiplicand_1 * const_0.into() + second_addend * const_1.into(); + let third_computed_output = third_multiplicand_0 * third_multiplicand_1 * const_0.into() + + third_addend * const_1.into(); + let fourth_computed_output = fourth_multiplicand_0 * fourth_multiplicand_1 * const_0.into() + + fourth_addend * const_1.into(); let mut constraints = (first_output - first_computed_output) .to_basefield_array() .to_vec(); constraints.extend((second_output - second_computed_output).to_basefield_array()); + constraints.extend((third_output - third_computed_output).to_basefield_array()); + constraints.extend((fourth_output - fourth_computed_output).to_basefield_array()); constraints } @@ -81,18 +122,32 @@ impl, const D: usize> Gate for ArithmeticExtensionGate let second_multiplicand_0 = vars.get_local_ext(Self::wires_second_multiplicand_0()); let second_multiplicand_1 = vars.get_local_ext(Self::wires_second_multiplicand_1()); let second_addend = vars.get_local_ext(Self::wires_second_addend()); + let third_multiplicand_0 = vars.get_local_ext(Self::wires_third_multiplicand_0()); + let third_multiplicand_1 = vars.get_local_ext(Self::wires_third_multiplicand_1()); + let third_addend = vars.get_local_ext(Self::wires_third_addend()); + let fourth_multiplicand_0 = vars.get_local_ext(Self::wires_fourth_multiplicand_0()); + let fourth_multiplicand_1 = vars.get_local_ext(Self::wires_fourth_multiplicand_1()); + let fourth_addend = vars.get_local_ext(Self::wires_fourth_addend()); let first_output = vars.get_local_ext(Self::wires_first_output()); let second_output = vars.get_local_ext(Self::wires_second_output()); + let third_output = vars.get_local_ext(Self::wires_third_output()); + let fourth_output = vars.get_local_ext(Self::wires_fourth_output()); let first_computed_output = first_multiplicand_0 * first_multiplicand_1 * const_0.into() + first_addend * const_1.into(); let second_computed_output = second_multiplicand_0 * second_multiplicand_1 * const_0.into() + second_addend * const_1.into(); + let third_computed_output = third_multiplicand_0 * third_multiplicand_1 * const_0.into() + + third_addend * const_1.into(); + let fourth_computed_output = fourth_multiplicand_0 * fourth_multiplicand_1 * const_0.into() + + fourth_addend * const_1.into(); let mut constraints = (first_output - first_computed_output) .to_basefield_array() .to_vec(); constraints.extend((second_output - second_computed_output).to_basefield_array()); + constraints.extend((third_output - third_computed_output).to_basefield_array()); + constraints.extend((fourth_output - fourth_computed_output).to_basefield_array()); constraints } @@ -110,8 +165,16 @@ impl, const D: usize> Gate for ArithmeticExtensionGate let second_multiplicand_0 = vars.get_local_ext_algebra(Self::wires_second_multiplicand_0()); let second_multiplicand_1 = vars.get_local_ext_algebra(Self::wires_second_multiplicand_1()); let second_addend = vars.get_local_ext_algebra(Self::wires_second_addend()); + let third_multiplicand_0 = vars.get_local_ext_algebra(Self::wires_third_multiplicand_0()); + let third_multiplicand_1 = vars.get_local_ext_algebra(Self::wires_third_multiplicand_1()); + let third_addend = vars.get_local_ext_algebra(Self::wires_third_addend()); + let fourth_multiplicand_0 = vars.get_local_ext_algebra(Self::wires_fourth_multiplicand_0()); + let fourth_multiplicand_1 = vars.get_local_ext_algebra(Self::wires_fourth_multiplicand_1()); + let fourth_addend = vars.get_local_ext_algebra(Self::wires_fourth_addend()); let first_output = vars.get_local_ext_algebra(Self::wires_first_output()); let second_output = vars.get_local_ext_algebra(Self::wires_second_output()); + let third_output = vars.get_local_ext_algebra(Self::wires_third_output()); + let fourth_output = vars.get_local_ext_algebra(Self::wires_fourth_output()); let first_computed_output = builder.mul_ext_algebra(first_multiplicand_0, first_multiplicand_1); @@ -128,10 +191,29 @@ impl, const D: usize> Gate for ArithmeticExtensionGate let second_computed_output = builder.add_ext_algebra(second_computed_output, second_scaled_addend); + let third_computed_output = + builder.mul_ext_algebra(third_multiplicand_0, third_multiplicand_1); + let third_computed_output = builder.scalar_mul_ext_algebra(const_0, third_computed_output); + let third_scaled_addend = builder.scalar_mul_ext_algebra(const_1, third_addend); + let third_computed_output = + builder.add_ext_algebra(third_computed_output, third_scaled_addend); + + let fourth_computed_output = + builder.mul_ext_algebra(fourth_multiplicand_0, fourth_multiplicand_1); + let fourth_computed_output = + builder.scalar_mul_ext_algebra(const_0, fourth_computed_output); + let fourth_scaled_addend = builder.scalar_mul_ext_algebra(const_1, fourth_addend); + let fourth_computed_output = + builder.add_ext_algebra(fourth_computed_output, fourth_scaled_addend); + let diff_0 = builder.sub_ext_algebra(first_output, first_computed_output); let diff_1 = builder.sub_ext_algebra(second_output, second_computed_output); + let diff_2 = builder.sub_ext_algebra(third_output, third_computed_output); + let diff_3 = builder.sub_ext_algebra(fourth_output, fourth_computed_output); let mut constraints = diff_0.to_ext_target_array().to_vec(); constraints.extend(diff_1.to_ext_target_array()); + constraints.extend(diff_2.to_ext_target_array()); + constraints.extend(diff_3.to_ext_target_array()); constraints } @@ -140,21 +222,24 @@ impl, const D: usize> Gate for ArithmeticExtensionGate gate_index: usize, local_constants: &[F], ) -> Vec>> { - let gen0 = ArithmeticExtensionGenerator0 { - gate_index, - const_0: local_constants[0], - const_1: local_constants[1], - }; - let gen1 = ArithmeticExtensionGenerator1 { - gate_index, - const_0: local_constants[0], - const_1: local_constants[1], - }; - vec![Box::new(gen0), Box::new(gen1)] + let gens = (0..4) + .map(|i| ArithmeticExtensionGenerator { + gate_index, + const_0: local_constants[0], + const_1: local_constants[1], + i, + }) + .collect::>(); + vec![ + Box::new(gens[0].clone()), + Box::new(gens[1].clone()), + Box::new(gens[2].clone()), + Box::new(gens[3].clone()), + ] } fn num_wires(&self) -> usize { - 8 * D + 16 * D } fn num_constants(&self) -> usize { @@ -166,27 +251,21 @@ impl, const D: usize> Gate for ArithmeticExtensionGate } fn num_constraints(&self) -> usize { - 2 * D + 4 * D } } -struct ArithmeticExtensionGenerator0, const D: usize> { +#[derive(Clone)] +struct ArithmeticExtensionGenerator, const D: usize> { gate_index: usize, const_0: F, const_1: F, + i: usize, } -struct ArithmeticExtensionGenerator1, const D: usize> { - gate_index: usize, - const_0: F, - const_1: F, -} - -impl, const D: usize> SimpleGenerator for ArithmeticExtensionGenerator0 { +impl, const D: usize> SimpleGenerator for ArithmeticExtensionGenerator { fn dependencies(&self) -> Vec { - ArithmeticExtensionGate::::wires_first_multiplicand_0() - .chain(ArithmeticExtensionGate::::wires_first_multiplicand_1()) - .chain(ArithmeticExtensionGate::::wires_first_addend()) + (4 * self.i * D..(4 * self.i + 3) * D) .map(|i| Target::wire(self.gate_index, i)) .collect() } @@ -197,49 +276,13 @@ impl, const D: usize> SimpleGenerator for ArithmeticExtensio witness.get_extension_target(t) }; - let multiplicand_0 = - extract_extension(ArithmeticExtensionGate::::wires_first_multiplicand_0()); - let multiplicand_1 = - extract_extension(ArithmeticExtensionGate::::wires_first_multiplicand_1()); - let addend = extract_extension(ArithmeticExtensionGate::::wires_first_addend()); + let start = 4 * self.i * D; + let multiplicand_0 = extract_extension(start..start + D); + let multiplicand_1 = extract_extension(start + D..start + 2 * D); + let addend = extract_extension(start + 2 * D..start + 3 * D); - let output_target = ExtensionTarget::from_range( - self.gate_index, - ArithmeticExtensionGate::::wires_first_output(), - ); - - let computed_output = - multiplicand_0 * multiplicand_1 * self.const_0.into() + addend * self.const_1.into(); - - out_buffer.set_extension_target(output_target, computed_output) - } -} - -impl, const D: usize> SimpleGenerator for ArithmeticExtensionGenerator1 { - fn dependencies(&self) -> Vec { - ArithmeticExtensionGate::::wires_second_multiplicand_0() - .chain(ArithmeticExtensionGate::::wires_second_multiplicand_1()) - .chain(ArithmeticExtensionGate::::wires_second_addend()) - .map(|i| Target::wire(self.gate_index, i)) - .collect() - } - - fn run_once(&self, witness: &PartialWitness, out_buffer: &mut GeneratedValues) { - let extract_extension = |range: Range| -> F::Extension { - let t = ExtensionTarget::from_range(self.gate_index, range); - witness.get_extension_target(t) - }; - - let multiplicand_0 = - extract_extension(ArithmeticExtensionGate::::wires_second_multiplicand_0()); - let multiplicand_1 = - extract_extension(ArithmeticExtensionGate::::wires_second_multiplicand_1()); - let addend = extract_extension(ArithmeticExtensionGate::::wires_second_addend()); - - let output_target = ExtensionTarget::from_range( - self.gate_index, - ArithmeticExtensionGate::::wires_second_output(), - ); + let output_target = + ExtensionTarget::from_range(self.gate_index, start + 3 * D..start + 4 * D); let computed_output = multiplicand_0 * multiplicand_1 * self.const_0.into() + addend * self.const_1.into(); diff --git a/src/iop/generator.rs b/src/iop/generator.rs index 6ab1b412..189648c5 100644 --- a/src/iop/generator.rs +++ b/src/iop/generator.rs @@ -76,10 +76,10 @@ pub(crate) fn generate_partial_witness( pending_generator_indices = next_pending_generator_indices; } - assert!( - generator_is_expired.into_iter().all(identity), - "Some generators weren't run." - ); + // assert!( + // generator_is_expired.into_iter().all(identity), + // "Some generators weren't run." + // ); } /// A generator participates in the generation of the witness. diff --git a/src/plonk/circuit_builder.rs b/src/plonk/circuit_builder.rs index d783d890..bae4b5d6 100644 --- a/src/plonk/circuit_builder.rs +++ b/src/plonk/circuit_builder.rs @@ -60,6 +60,8 @@ pub struct CircuitBuilder, const D: usize> { constants_to_targets: HashMap, targets_to_constants: HashMap, + + pub(crate) free_arithmetic: Option<(usize, F, F)>, } impl, const D: usize> CircuitBuilder { @@ -76,6 +78,7 @@ impl, const D: usize> CircuitBuilder { generators: Vec::new(), constants_to_targets: HashMap::new(), targets_to_constants: HashMap::new(), + free_arithmetic: None, } } diff --git a/src/plonk/circuit_data.rs b/src/plonk/circuit_data.rs index 2441d810..59aaa485 100644 --- a/src/plonk/circuit_data.rs +++ b/src/plonk/circuit_data.rs @@ -66,11 +66,11 @@ impl CircuitConfig { security_bits: 128, rate_bits: 3, num_challenges: 3, - zero_knowledge: true, + zero_knowledge: false, cap_height: 1, fri_config: FriConfig { proof_of_work_bits: 1, - reduction_arity_bits: vec![1, 1, 1, 1], + reduction_arity_bits: vec![1], num_query_rounds: 1, cap_height: 1, }, diff --git a/src/plonk/recursive_verifier.rs b/src/plonk/recursive_verifier.rs index 369fbcb1..792c8270 100644 --- a/src/plonk/recursive_verifier.rs +++ b/src/plonk/recursive_verifier.rs @@ -97,8 +97,13 @@ impl, const D: usize> CircuitBuilder { .chunks(inner_common_data.quotient_degree_factor) .enumerate() { + dbg!(chunk.len()); let recombined_quotient = scale.reduce(chunk, self); + self.add_marked(z_h_zeta.into(), &format!("zhz {}", i)); + self.add_marked(recombined_quotient.into(), &format!("recomb {}", i)); let computed_vanishing_poly = self.mul_extension(z_h_zeta, recombined_quotient); + self.add_marked(vanishing_polys_zeta[i].into(), &format!("yo {}", i)); + self.add_marked(computed_vanishing_poly.into(), &format!("ya {}", i)); self.named_assert_equal_extension( vanishing_polys_zeta[i], computed_vanishing_poly, @@ -444,7 +449,7 @@ mod tests { let mut builder = CircuitBuilder::::new(config.clone()); let _two = builder.two(); let mut _two = builder.hash_n_to_hash(vec![_two], true).elements[0]; - for _ in 0..10000 { + for _ in 0..20000 { _two = builder.mul(_two, _two); } let data = builder.build(); diff --git a/src/plonk/vanishing_poly.rs b/src/plonk/vanishing_poly.rs index e2180552..1f7526e2 100644 --- a/src/plonk/vanishing_poly.rs +++ b/src/plonk/vanishing_poly.rs @@ -382,6 +382,9 @@ pub(crate) fn eval_vanishing_poly_recursively, const D: usize>( ] .concat(); + for (i, &v) in vanishing_terms.iter().enumerate() { + builder.add_marked(v.into(), &format!("v {}", i)); + } alphas .iter() .map(|&alpha| { diff --git a/src/util/reducing.rs b/src/util/reducing.rs index 8e8fa661..479e7e39 100644 --- a/src/util/reducing.rs +++ b/src/util/reducing.rs @@ -176,16 +176,30 @@ impl ReducingFactorTarget { terms_vec.reverse(); let mut acc = zero; + let mut countt = 0; + dbg!(terms_vec.len()); for pair in terms_vec.chunks(2) { // We will route the output of the first arithmetic operation to the multiplicand of the // second, i.e. we compute the following: // out_0 = alpha acc + pair[0] // acc' = out_1 = alpha out_0 + pair[1] - let gate = builder.num_gates(); - let out_0 = ExtensionTarget::from_range( - gate, - ArithmeticExtensionGate::::wires_first_output(), - ); + + let (gate, range) = if let Some((g, c_0, c_1)) = builder.free_arithmetic { + if g == builder.num_gates() - 1 && c_0 == F::ONE && c_1 == F::ONE { + (g, ArithmeticExtensionGate::::wires_third_output()) + } else { + ( + builder.num_gates(), + ArithmeticExtensionGate::::wires_first_output(), + ) + } + } else { + ( + builder.num_gates(), + ArithmeticExtensionGate::::wires_first_output(), + ) + }; + let out_0 = ExtensionTarget::from_range(gate, range); acc = builder .double_arithmetic_extension( F::ONE, @@ -198,6 +212,9 @@ impl ReducingFactorTarget { pair[1], ) .1; + // dbg!(countt, acc); + // builder.add_marked(acc.into(), &format!("acc {}", countt)); + countt += 1; } acc }