Parse conditional multi

executor/src/witgen/jit/block_machine_processor.rs

@@ -391,7 +391,7 @@ params[3] = main_binary::C[3];"
         assert_eq!(
             format_code(&code),
             "Sub::a[0] = params[0];
-Sub::b[0] = prover_function_0(0, [Sub::a[0]]);
+[Sub::b[0]] = prover_function_0(0, [Sub::a[0]]);
 params[1] = Sub::b[0];"
         );
     }

executor/src/witgen/jit/compiler.rs

@@ -361,15 +361,15 @@ fn format_effect<T: FieldElement>(effect: &Effect<T, Variable>, is_top_level: bo
             )
         }
         Effect::ProverFunctionCall(ProverFunctionCall {
-            target,
+            targets,
             function_index,
             row_offset,
             inputs,
         }) => {
             format!(
-                "{}{} = prover_function_{function_index}(row_offset + {row_offset}, &[{}]);",
+                "{}[{}] = prover_function_{function_index}(row_offset + {row_offset}, &[{}]);",
                 if is_top_level { "let " } else { "" },
-                variable_to_string(target),
+                targets.iter().map(variable_to_string).format(", "),
                 inputs.iter().map(variable_to_string).format(", ")
             )
         }

executor/src/witgen/jit/effect.rs

@@ -43,8 +43,8 @@ impl<T: FieldElement> Effect<T, Variable> {
                     .zip_eq(known)
                     .flat_map(|(v, known)| (!known).then_some((v, true))),
             ),
-            Effect::ProverFunctionCall(ProverFunctionCall { target, .. }) => {
-                Box::new(iter::once((target, false)))
+            Effect::ProverFunctionCall(ProverFunctionCall { targets, .. }) => {
+                Box::new(targets.iter().map(|v| (v, false)))
             }
             Effect::Branch(_, first, second) => {
                 Box::new(first.iter().chain(second).flat_map(|e| e.written_vars()))
@@ -63,9 +63,9 @@ impl<T: FieldElement, V: Hash + Eq> Effect<T, V> {
                 Box::new(lhs.referenced_symbols().chain(rhs.referenced_symbols()))
             }
             Effect::MachineCall(_, _, args) => Box::new(args.iter()),
-            Effect::ProverFunctionCall(ProverFunctionCall { target, inputs, .. }) => {
-                Box::new(iter::once(target).chain(inputs))
-            }
+            Effect::ProverFunctionCall(ProverFunctionCall {
+                targets, inputs, ..
+            }) => Box::new(targets.iter().chain(inputs)),
             Effect::Branch(branch_condition, first, second) => Box::new(
                 iter::once(&branch_condition.variable).chain(
                     [first, second]
@@ -123,8 +123,8 @@ pub struct BranchCondition<T: FieldElement, V> {
 
 #[derive(Clone, PartialEq, Eq)]
 pub struct ProverFunctionCall<V> {
-    /// Which variable to assign the result to.
-    pub target: V,
+    /// Which variables to assign the result to.
+    pub targets: Vec<V>,
     /// The index of the prover function in the list.
     pub function_index: usize,
     /// The row offset to supply to the prover function.
@@ -166,13 +166,14 @@ pub fn format_code<T: FieldElement>(effects: &[Effect<T, Variable>]) -> String {
                 panic!("Range constraints should not be part of the code.")
             }
             Effect::ProverFunctionCall(ProverFunctionCall {
-                target,
+                targets,
                 function_index,
                 row_offset,
                 inputs,
             }) => {
                 format!(
-                    "{target} = prover_function_{function_index}({row_offset}, [{}]);",
+                    "[{}] = prover_function_{function_index}({row_offset}, [{}]);",
+                    targets.iter().join(", "),
                     inputs.iter().join(", ")
                 )
             }

executor/src/witgen/jit/processor.rs

@@ -31,7 +31,7 @@ pub struct Processor<'a, T: FieldElement, FixedEval> {
     identities: Vec<(&'a Identity<T>, i32)>,
     /// The prover functions, i.e. helpers to compute certain values that
     /// we cannot easily determine.
-    prover_functions: Vec<(ProverFunction<'a>, i32)>,
+    prover_functions: Vec<(ProverFunction<'a, T>, i32)>,
     /// The size of a block.
     block_size: usize,
     /// If the processor should check for correctly stackable block shapes.
@@ -99,7 +99,7 @@ impl<'a, T: FieldElement, FixedEval: FixedEvaluator<T>> Processor<'a, T, FixedEv
 
     pub fn with_prover_functions(
         mut self,
-        prover_functions: Vec<(ProverFunction<'a>, i32)>,
+        prover_functions: Vec<(ProverFunction<'a, T>, i32)>,
     ) -> Self {
         assert!(self.prover_functions.is_empty());
         self.prover_functions = prover_functions;