diff --git a/Cargo.toml b/Cargo.toml index 36de3cedc..8683cb805 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,6 +9,7 @@ members = [ "codegen/winterfell", "codegen/ace", "codegen/plonky3", + "constraints", ] resolver = "2" diff --git a/air-script/Cargo.toml b/air-script/Cargo.toml index ed1709f76..1deefad8c 100644 --- a/air-script/Cargo.toml +++ b/air-script/Cargo.toml @@ -28,10 +28,11 @@ log = { version = "0.4", default-features = false } miden-diagnostics = { workspace = true } mir = { package = "air-mir", path = "../mir", version = "0.5" } -# 0xMiden Plonky3 Fork -p3-matrix = { package = "p3-matrix", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-field = { package = "p3-field", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-miden-air = { package = "miden-air", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } +# Upstream Plonky3 dependencies +p3-field = { version = "0.4.2", default-features = false } +p3-matrix = { version = "0.4.2", default-features = false } +# Internal p3-miden crates +p3-miden-air = { package = "p3-miden-air", git = "https://github.com/0xMiden/p3-miden", rev = "b6cb824d2a462bbcbbfb828c158de220aa7ca11f", default-features = false } # MassaLabs fork miden-processor = { package = "miden-processor", git="https://github.com/massalabs/miden-vm", rev = "bc553af69a2543a0789830e8508b019694528181", default-features = false } @@ -40,17 +41,32 @@ miden-air = { package = "miden-air", git="https://github.com/massalabs/miden-vm" [dev-dependencies] expect-test = "1.4" -# 0xMiden Plonky3 Fork -p3-air = { package = "p3-air", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-challenger = { package = "p3-challenger", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-commit = { package = "p3-commit", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-dft = { package = "p3-dft", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-fri = { package = "p3-fri", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-merkle-tree = { package = "p3-merkle-tree", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-miden-prover = { package = "miden-prover", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-goldilocks = { package = "p3-goldilocks", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-sha256 = { package = "p3-sha256", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } -p3-symmetric = { package = "p3-symmetric", git="https://github.com/0xMiden/Plonky3", rev = "632fb26a9141cc70f903e5378035ca8d5855c490", default-features = false } +# Upstream Plonky3 dependencies +p3-air = { version = "0.4.2", default-features = false } +p3-baby-bear = { version = "0.4.2", default-features = false } +p3-challenger = { version = "0.4.2", default-features = false } +p3-circle = { version = "0.4.2", default-features = false } +p3-commit = { version = "0.4.2", default-features = false } +p3-dft = { version = "0.4.2", default-features = false } +p3-field-testing = { version = "0.4.2", default-features = false } +p3-goldilocks = { version = "0.4.2", default-features = false } +p3-interpolation = { version = "0.4.2", default-features = false } +p3-keccak = { version = "0.4.2", default-features = false } +p3-matrix = { version = "0.4.2", default-features = false } +p3-maybe-rayon = { version = "0.4.2", default-features = false } +p3-mds = { version = "0.4.2", default-features = false } +p3-merkle-tree = { version = "0.4.2", default-features = false } +p3-mersenne-31 = { version = "0.4.2", default-features = false } +p3-poseidon = { version = "0.4.2", default-features = false } +p3-poseidon2 = { version = "0.4.2", default-features = false } +p3-sha256 = { version = "0.4.2", default-features = false } +p3-symmetric = { version = "0.4.2", default-features = false } +p3-uni-stark = { version = "0.4.2", default-features = false } +p3-util = { version = "0.4.2", default-features = false } +# Internal p3-miden crates +p3-miden-fri = { package = "p3-miden-fri", git = "https://github.com/0xMiden/p3-miden", rev = "b6cb824d2a462bbcbbfb828c158de220aa7ca11f", default-features = false } +p3-miden-prover = { package = "p3-miden-prover", git = "https://github.com/0xMiden/p3-miden", rev = "b6cb824d2a462bbcbbfb828c158de220aa7ca11f", default-features = false } +p3-miden-uni-stark = { package = "p3-miden-uni-stark", git = "https://github.com/0xMiden/p3-miden", rev = "b6cb824d2a462bbcbbfb828c158de220aa7ca11f", default-features = false } winter-air = { package = "winter-air", version = "0.12", default-features = false } winter-math = { package = "winter-math", version = "0.12", default-features = false } diff --git a/air-script/src/test_utils/air_tester_macros.rs b/air-script/src/test_utils/air_tester_macros.rs index 7c5e305ee..663e53e7f 100644 --- a/air-script/src/test_utils/air_tester_macros.rs +++ b/air-script/src/test_utils/air_tester_macros.rs @@ -52,7 +52,7 @@ macro_rules! generate_air_plonky3_test_with_airscript_traits { p3_challenger::HashChallenger, >; type Dft = p3_dft::Radix2DitParallel; - type Pcs = p3_fri::TwoAdicFriPcs; + type Pcs = p3_miden_fri::TwoAdicFriPcs; type MyConfig = p3_miden_prover::StarkConfig; let byte_hash = ByteHash {}; @@ -62,7 +62,7 @@ macro_rules! generate_air_plonky3_test_with_airscript_traits { let challenge_mmcs = ChallengeMmcs::new(val_mmcs.clone()); let challenger = Challenger::from_hasher(vec![], byte_hash); let dft = Dft::default(); - let mut fri_params = p3_fri::create_recursive_miden_fri_params(challenge_mmcs); + let mut fri_params = p3_miden_fri::create_recursive_miden_fri_params(challenge_mmcs); let pcs = Pcs::new(dft, val_mmcs, fri_params); let config = MyConfig::new(pcs, challenger); diff --git a/air-script/src/tests/buses/buses_complex_plonky3.rs b/air-script/src/tests/buses/buses_complex_plonky3.rs index 2d038524d..09b4d81c3 100644 --- a/air-script/src/tests/buses/buses_complex_plonky3.rs +++ b/air-script/src/tests/buses/buses_complex_plonky3.rs @@ -29,8 +29,8 @@ where F: Field, AUX_WIDTH } - fn bus_types(&self) -> Vec { - vec![ + fn bus_types(&self) -> &[BusType] { + &[ BusType::Multiset, BusType::Logup, ] diff --git a/air-script/src/tests/buses/buses_simple_plonky3.rs b/air-script/src/tests/buses/buses_simple_plonky3.rs index 65efcf8fb..9644511c6 100644 --- a/air-script/src/tests/buses/buses_simple_plonky3.rs +++ b/air-script/src/tests/buses/buses_simple_plonky3.rs @@ -29,8 +29,8 @@ where F: Field, AUX_WIDTH } - fn bus_types(&self) -> Vec { - vec![ + fn bus_types(&self) -> &[BusType] { + &[ BusType::Multiset, BusType::Logup, ] diff --git a/air-script/src/tests/buses/buses_varlen_boundary_both_plonky3.rs b/air-script/src/tests/buses/buses_varlen_boundary_both_plonky3.rs index b32d738e1..34e3ee98b 100644 --- a/air-script/src/tests/buses/buses_varlen_boundary_both_plonky3.rs +++ b/air-script/src/tests/buses/buses_varlen_boundary_both_plonky3.rs @@ -29,8 +29,8 @@ where F: Field, AUX_WIDTH } - fn bus_types(&self) -> Vec { - vec![ + fn bus_types(&self) -> &[BusType] { + &[ BusType::Multiset, BusType::Logup, ] diff --git a/air-script/src/tests/buses/buses_varlen_boundary_first_plonky3.rs b/air-script/src/tests/buses/buses_varlen_boundary_first_plonky3.rs index b32d738e1..34e3ee98b 100644 --- a/air-script/src/tests/buses/buses_varlen_boundary_first_plonky3.rs +++ b/air-script/src/tests/buses/buses_varlen_boundary_first_plonky3.rs @@ -29,8 +29,8 @@ where F: Field, AUX_WIDTH } - fn bus_types(&self) -> Vec { - vec![ + fn bus_types(&self) -> &[BusType] { + &[ BusType::Multiset, BusType::Logup, ] diff --git a/air-script/src/tests/buses/buses_varlen_boundary_last_plonky3.rs b/air-script/src/tests/buses/buses_varlen_boundary_last_plonky3.rs index dba927c11..39e943a34 100644 --- a/air-script/src/tests/buses/buses_varlen_boundary_last_plonky3.rs +++ b/air-script/src/tests/buses/buses_varlen_boundary_last_plonky3.rs @@ -29,8 +29,8 @@ where F: Field, AUX_WIDTH } - fn bus_types(&self) -> Vec { - vec![ + fn bus_types(&self) -> &[BusType] { + &[ BusType::Multiset, BusType::Logup, ] diff --git a/air-script/src/tests/comprehension_periodic_binding/comprehension_periodic_binding.air b/air-script/src/tests/comprehension_periodic_binding/comprehension_periodic_binding.air new file mode 100644 index 000000000..a21bbcbd5 --- /dev/null +++ b/air-script/src/tests/comprehension_periodic_binding/comprehension_periodic_binding.air @@ -0,0 +1,19 @@ +def ComprehensionPeriodicBindingTest + +use lib::test_comprehension; + +trace_columns { + main: [a, b], +} + +public_inputs { + stack_inputs: [1], +} + +boundary_constraints { + enf a.first = 0; +} + +integrity_constraints { + enf test_comprehension([a, b]); +} diff --git a/air-script/src/tests/comprehension_periodic_binding/comprehension_periodic_binding.rs b/air-script/src/tests/comprehension_periodic_binding/comprehension_periodic_binding.rs new file mode 100644 index 000000000..9e56fa9e2 --- /dev/null +++ b/air-script/src/tests/comprehension_periodic_binding/comprehension_periodic_binding.rs @@ -0,0 +1,97 @@ +use winter_air::{Air, AirContext, Assertion, AuxRandElements, EvaluationFrame, ProofOptions as WinterProofOptions, TransitionConstraintDegree, TraceInfo}; +use winter_math::fields::f64::BaseElement as Felt; +use winter_math::{ExtensionOf, FieldElement, ToElements}; +use winter_utils::{ByteWriter, Serializable}; + +pub struct PublicInputs { + stack_inputs: [Felt; 1], +} + +impl PublicInputs { + pub fn new(stack_inputs: [Felt; 1]) -> Self { + Self { stack_inputs } + } +} + +impl Serializable for PublicInputs { + fn write_into(&self, target: &mut W) { + self.stack_inputs.write_into(target); + } +} + +impl ToElements for PublicInputs { + fn to_elements(&self) -> Vec { + let mut elements = Vec::new(); + elements.extend_from_slice(&self.stack_inputs); + elements + } +} + +pub struct ComprehensionPeriodicBindingTest { + context: AirContext, + stack_inputs: [Felt; 1], +} + +impl ComprehensionPeriodicBindingTest { + pub fn last_step(&self) -> usize { + self.trace_length() - self.context().num_transition_exemptions() + } +} + +impl Air for ComprehensionPeriodicBindingTest { + type BaseField = Felt; + type PublicInputs = PublicInputs; + + fn context(&self) -> &AirContext { + &self.context + } + + fn new(trace_info: TraceInfo, public_inputs: PublicInputs, options: WinterProofOptions) -> Self { + let main_degrees = vec![TransitionConstraintDegree::with_cycles(1, vec![2, 2])]; + let aux_degrees = vec![]; + let num_main_assertions = 1; + let num_aux_assertions = 0; + + let context = AirContext::new_multi_segment( + trace_info, + main_degrees, + aux_degrees, + num_main_assertions, + num_aux_assertions, + options, + ) + .set_num_transition_exemptions(2); + Self { context, stack_inputs: public_inputs.stack_inputs } + } + + fn get_periodic_column_values(&self) -> Vec> { + vec![vec![Felt::ONE, Felt::new(2)], vec![Felt::new(3), Felt::new(4)]] + } + + fn get_assertions(&self) -> Vec> { + let mut result = Vec::new(); + result.push(Assertion::single(0, 0, Felt::ZERO)); + result + } + + fn get_aux_assertions>(&self, aux_rand_elements: &AuxRandElements) -> Vec> { + let mut result = Vec::new(); + result + } + + fn evaluate_transition>(&self, frame: &EvaluationFrame, periodic_values: &[E], result: &mut [E]) { + let main_current = frame.current(); + let main_next = frame.next(); + result[0] = main_next[0] - (main_current[0] * periodic_values[0] + main_current[1] * periodic_values[1]); + } + + fn evaluate_aux_transition(&self, main_frame: &EvaluationFrame, aux_frame: &EvaluationFrame, _periodic_values: &[F], aux_rand_elements: &AuxRandElements, result: &mut [E]) + where F: FieldElement, + E: FieldElement + ExtensionOf, + { + let main_current = main_frame.current(); + let main_next = main_frame.next(); + let aux_current = aux_frame.current(); + let aux_next = aux_frame.next(); + } +} \ No newline at end of file diff --git a/air-script/src/tests/comprehension_periodic_binding/comprehension_periodic_binding_plonky3.rs b/air-script/src/tests/comprehension_periodic_binding/comprehension_periodic_binding_plonky3.rs new file mode 100644 index 000000000..a095ec7f0 --- /dev/null +++ b/air-script/src/tests/comprehension_periodic_binding/comprehension_periodic_binding_plonky3.rs @@ -0,0 +1,56 @@ +use p3_field::{ExtensionField, Field, PrimeCharacteristicRing}; +use p3_matrix::Matrix; +use p3_matrix::dense::RowMajorMatrixView; +use p3_matrix::stack::VerticalPair; +use p3_miden_air::{BusType, MidenAir, MidenAirBuilder, RowMajorMatrix}; + +pub const MAIN_WIDTH: usize = 2; +pub const AUX_WIDTH: usize = 0; +pub const NUM_PERIODIC_VALUES: usize = 2; +pub const PERIOD: usize = 2; +pub const NUM_PUBLIC_VALUES: usize = 1; +pub const MAX_BETA_CHALLENGE_POWER: usize = 0; + +pub struct ComprehensionPeriodicBindingTest; + +impl MidenAir for ComprehensionPeriodicBindingTest +where F: Field, + EF: ExtensionField, +{ + fn width(&self) -> usize { + MAIN_WIDTH + } + + fn num_public_values(&self) -> usize { + NUM_PUBLIC_VALUES + } + + fn periodic_table(&self) -> Vec> { + vec![ + vec![F::from_u64(1), F::from_u64(2)], + vec![F::from_u64(3), F::from_u64(4)], + ] + } + + fn eval(&self, builder: &mut AB) + where AB: MidenAirBuilder, + { + let public_values: [_; NUM_PUBLIC_VALUES] = builder.public_values().try_into().expect("Wrong number of public values"); + let periodic_values: [_; NUM_PERIODIC_VALUES] = builder.periodic_evals().try_into().expect("Wrong number of periodic values"); + // Note: for now, we do not have any preprocessed values + // let preprocessed = builder.preprocessed(); + let main = builder.main(); + let (main_current, main_next) = ( + main.row_slice(0).unwrap(), + main.row_slice(1).unwrap(), + ); + + // Main boundary constraints + builder.when_first_row().assert_zero(main_current[0].clone().into()); + + // Main integrity/transition constraints + builder.when_transition().assert_zero_ext(AB::ExprEF::from(main_next[0].clone().into()) - (AB::ExprEF::from(main_current[0].clone().into()) * AB::ExprEF::from(periodic_values[0].clone().into()) + AB::ExprEF::from(main_current[1].clone().into()) * AB::ExprEF::from(periodic_values[1].clone().into()))); + + // Aux integrity/transition constraints + } +} \ No newline at end of file diff --git a/air-script/src/tests/comprehension_periodic_binding/lib.air b/air-script/src/tests/comprehension_periodic_binding/lib.air new file mode 100644 index 000000000..8667dc9ae --- /dev/null +++ b/air-script/src/tests/comprehension_periodic_binding/lib.air @@ -0,0 +1,16 @@ +mod lib + +periodic_columns { + k0: [1, 2], + k1: [3, 4], +} + +ev test_comprehension([a, b]) { + # Create local variable holding periodic column references + let cols = [k0, k1]; + let vals = [a, b]; + + # Iterate over the local variable - binding 'k' gets typed as PeriodicColumn + # but it's actually a local variable holding a value + enf a' = sum([x * k for (x, k) in (vals, cols)]); +} diff --git a/air-script/src/tests/comprehension_periodic_binding/mod.rs b/air-script/src/tests/comprehension_periodic_binding/mod.rs new file mode 100644 index 000000000..83244b98e --- /dev/null +++ b/air-script/src/tests/comprehension_periodic_binding/mod.rs @@ -0,0 +1,3 @@ +#[rustfmt::skip] +#[allow(clippy::all)] +mod comprehension_periodic_binding; diff --git a/air-script/src/tests/cross_module_constants/constants_lib.air b/air-script/src/tests/cross_module_constants/constants_lib.air new file mode 100644 index 000000000..25ef19270 --- /dev/null +++ b/air-script/src/tests/cross_module_constants/constants_lib.air @@ -0,0 +1,21 @@ +mod constants_lib + +# Constants used in comprehension iterables +const WEIGHTS = [1, 2, 3, 4]; + +# Pure function that uses constants in a comprehension +fn weighted_sum(values: felt[4]) -> felt { + return sum([v * w for (v, w) in (values, WEIGHTS)]); +} + +# Another function that calls the first +fn compute_result(a: felt, b: felt, c: felt, d: felt) -> felt { + let values = [a, b, c, d]; + return weighted_sum(values); +} + +# Evaluator that uses the chain of functions +ev apply_computation([cols[5]]) { + let result = compute_result(cols[0], cols[1], cols[2], cols[3]); + enf cols[4] = result; +} diff --git a/air-script/src/tests/cross_module_constants/cross_mod_constants.rs b/air-script/src/tests/cross_module_constants/cross_mod_constants.rs new file mode 100644 index 000000000..5de652283 --- /dev/null +++ b/air-script/src/tests/cross_module_constants/cross_mod_constants.rs @@ -0,0 +1,97 @@ +use winter_air::{Air, AirContext, Assertion, AuxRandElements, EvaluationFrame, ProofOptions as WinterProofOptions, TransitionConstraintDegree, TraceInfo}; +use winter_math::fields::f64::BaseElement as Felt; +use winter_math::{ExtensionOf, FieldElement, ToElements}; +use winter_utils::{ByteWriter, Serializable}; + +pub struct PublicInputs { + expected: [Felt; 1], +} + +impl PublicInputs { + pub fn new(expected: [Felt; 1]) -> Self { + Self { expected } + } +} + +impl Serializable for PublicInputs { + fn write_into(&self, target: &mut W) { + self.expected.write_into(target); + } +} + +impl ToElements for PublicInputs { + fn to_elements(&self) -> Vec { + let mut elements = Vec::new(); + elements.extend_from_slice(&self.expected); + elements + } +} + +pub struct CrossModuleConstantsTest { + context: AirContext, + expected: [Felt; 1], +} + +impl CrossModuleConstantsTest { + pub fn last_step(&self) -> usize { + self.trace_length() - self.context().num_transition_exemptions() + } +} + +impl Air for CrossModuleConstantsTest { + type BaseField = Felt; + type PublicInputs = PublicInputs; + + fn context(&self) -> &AirContext { + &self.context + } + + fn new(trace_info: TraceInfo, public_inputs: PublicInputs, options: WinterProofOptions) -> Self { + let main_degrees = vec![TransitionConstraintDegree::new(1)]; + let aux_degrees = vec![]; + let num_main_assertions = 1; + let num_aux_assertions = 0; + + let context = AirContext::new_multi_segment( + trace_info, + main_degrees, + aux_degrees, + num_main_assertions, + num_aux_assertions, + options, + ) + .set_num_transition_exemptions(2); + Self { context, expected: public_inputs.expected } + } + + fn get_periodic_column_values(&self) -> Vec> { + vec![] + } + + fn get_assertions(&self) -> Vec> { + let mut result = Vec::new(); + result.push(Assertion::single(0, 0, Felt::ZERO)); + result + } + + fn get_aux_assertions>(&self, aux_rand_elements: &AuxRandElements) -> Vec> { + let mut result = Vec::new(); + result + } + + fn evaluate_transition>(&self, frame: &EvaluationFrame, periodic_values: &[E], result: &mut [E]) { + let main_current = frame.current(); + let main_next = frame.next(); + result[0] = main_current[4] - (main_current[0] + main_current[1] * E::from(Felt::new(2_u64)) + main_current[2] * E::from(Felt::new(3_u64)) + main_current[3] * E::from(Felt::new(4_u64))); + } + + fn evaluate_aux_transition(&self, main_frame: &EvaluationFrame, aux_frame: &EvaluationFrame, _periodic_values: &[F], aux_rand_elements: &AuxRandElements, result: &mut [E]) + where F: FieldElement, + E: FieldElement + ExtensionOf, + { + let main_current = main_frame.current(); + let main_next = main_frame.next(); + let aux_current = aux_frame.current(); + let aux_next = aux_frame.next(); + } +} \ No newline at end of file diff --git a/air-script/src/tests/cross_module_constants/cross_mod_constants_plonky3.rs b/air-script/src/tests/cross_module_constants/cross_mod_constants_plonky3.rs new file mode 100644 index 000000000..47dc1b334 --- /dev/null +++ b/air-script/src/tests/cross_module_constants/cross_mod_constants_plonky3.rs @@ -0,0 +1,42 @@ +use p3_field::{ExtensionField, Field, PrimeCharacteristicRing}; +use p3_matrix::Matrix; +use p3_matrix::dense::RowMajorMatrixView; +use p3_matrix::stack::VerticalPair; +use p3_miden_air::{BusType, MidenAir, MidenAirBuilder, RowMajorMatrix}; + +pub const MAIN_WIDTH: usize = 5; +pub const AUX_WIDTH: usize = 0; +pub const NUM_PERIODIC_VALUES: usize = 0; +pub const PERIOD: usize = 0; +pub const NUM_PUBLIC_VALUES: usize = 1; +pub const MAX_BETA_CHALLENGE_POWER: usize = 0; + +pub struct CrossModuleConstantsTest; + +impl MidenAir for CrossModuleConstantsTest { + fn width(&self) -> usize { + MAIN_WIDTH + } + + fn eval(&self, builder: &mut AB) + where AB: MidenAirBuilder, + { + let public_values: [_; NUM_PUBLIC_VALUES] = builder.public_values().try_into().expect("Wrong number of public values"); + let periodic_values: [_; NUM_PERIODIC_VALUES] = builder.periodic_evals().try_into().expect("Wrong number of periodic values"); + // Note: for now, we do not have any preprocessed values + // let preprocessed = builder.preprocessed(); + let main = builder.main(); + let (main_current, main_next) = ( + main.row_slice(0).unwrap(), + main.row_slice(1).unwrap(), + ); + + // Main boundary constraints + builder.when_first_row().assert_zero(main_current[0].clone().into()); + + // Main integrity/transition constraints + builder.assert_zero(main_current[4].clone().into() - (main_current[0].clone().into() + main_current[1].clone().into().double() + main_current[2].clone().into() * AB::Expr::from_u64(3) + main_current[3].clone().into() * AB::Expr::from_u64(4))); + + // Aux integrity/transition constraints + } +} \ No newline at end of file diff --git a/air-script/src/tests/cross_module_constants/cross_module_constants.air b/air-script/src/tests/cross_module_constants/cross_module_constants.air new file mode 100644 index 000000000..87315ecd6 --- /dev/null +++ b/air-script/src/tests/cross_module_constants/cross_module_constants.air @@ -0,0 +1,21 @@ +def CrossModuleConstantsTest + +# Import evaluator that uses a chain: apply_computation -> compute_result -> weighted_sum -> WEIGHTS constant +use constants_lib::apply_computation; + +trace_columns { + main: [a, b, c, d, result], +} + +public_inputs { + expected: [1], +} + +boundary_constraints { + enf a.first = 0; +} + +integrity_constraints { + # Use imported evaluator that internally uses constants in comprehensions + enf apply_computation([a, b, c, d, result]); +} diff --git a/air-script/src/tests/cross_module_constants/mod.rs b/air-script/src/tests/cross_module_constants/mod.rs new file mode 100644 index 000000000..e10ee53c7 --- /dev/null +++ b/air-script/src/tests/cross_module_constants/mod.rs @@ -0,0 +1,3 @@ +#[rustfmt::skip] +#[allow(clippy::all)] +mod cross_mod_constants; diff --git a/air-script/src/tests/mod.rs b/air-script/src/tests/mod.rs index a140647c8..75bd5f39a 100644 --- a/air-script/src/tests/mod.rs +++ b/air-script/src/tests/mod.rs @@ -5,6 +5,8 @@ mod bitwise; #[allow(unused_variables, dead_code, unused_mut)] mod buses; #[allow(unused_variables, dead_code, unused_mut)] +mod comprehension_periodic_binding; +#[allow(unused_variables, dead_code, unused_mut)] mod computed_indices; #[allow(unused_variables, dead_code, unused_mut)] mod constant_in_range; @@ -13,6 +15,8 @@ mod constants; #[allow(unused_variables, dead_code, unused_mut)] mod constraint_comprehension; #[allow(unused_variables, dead_code, unused_mut)] +mod cross_module_constants; +#[allow(unused_variables, dead_code, unused_mut)] mod evaluators; #[allow(unused_variables, dead_code, unused_mut)] mod fibonacci; diff --git a/air-script/src/tests/plonky3.rs b/air-script/src/tests/plonky3.rs index baf9c3453..9a685d06d 100644 --- a/air-script/src/tests/plonky3.rs +++ b/air-script/src/tests/plonky3.rs @@ -81,6 +81,21 @@ fn buses_varlen_boundary_last() { expected.assert_eq(&generated_air); } +#[test] +fn comprehension_periodic_binding() { + // Test that comprehension bindings over periodic columns are typed as Local, not PeriodicColumn + // This pattern is used when iterating over a vector containing periodic column references + let generated_air = Test::new( + "src/tests/comprehension_periodic_binding/comprehension_periodic_binding.air".to_string(), + ) + .transpile(Target::Plonky3) + .unwrap(); + + let expected = + expect_file!["comprehension_periodic_binding/comprehension_periodic_binding_plonky3.rs"]; + expected.assert_eq(&generated_air); +} + #[test] fn computed_indices_complex() { let generated_air = @@ -123,6 +138,18 @@ fn constants() { expected.assert_eq(&generated_air); } +#[test] +fn cross_module_constants() { + // Test that constants used in comprehension iterables work across module boundaries + let generated_air = + Test::new("src/tests/cross_module_constants/cross_module_constants.air".to_string()) + .transpile(Target::Plonky3) + .unwrap(); + + let expected = expect_file!["cross_module_constants/cross_mod_constants_plonky3.rs"]; + expected.assert_eq(&generated_air); +} + #[test] fn evaluators_nested_slice_call() { let generated_air = diff --git a/air-script/src/tests/selectors/selectors_combine_complex_plonky3.rs b/air-script/src/tests/selectors/selectors_combine_complex_plonky3.rs index a89f39d38..8bebdce34 100644 --- a/air-script/src/tests/selectors/selectors_combine_complex_plonky3.rs +++ b/air-script/src/tests/selectors/selectors_combine_complex_plonky3.rs @@ -29,8 +29,8 @@ where F: Field, AUX_WIDTH } - fn bus_types(&self) -> Vec { - vec![ + fn bus_types(&self) -> &[BusType] { + &[ BusType::Multiset, ] } diff --git a/air-script/src/tests/winterfell.rs b/air-script/src/tests/winterfell.rs index 5e9f044df..1c2b0b6af 100644 --- a/air-script/src/tests/winterfell.rs +++ b/air-script/src/tests/winterfell.rs @@ -82,6 +82,20 @@ fn buses_varlen_boundary_last() { expected.assert_eq(&generated_air); } +#[test] +fn comprehension_periodic_binding() { + // Test that comprehension bindings over periodic columns are typed as Local, not PeriodicColumn + // This pattern is used when iterating over a vector containing periodic column references + let generated_air = Test::new( + "src/tests/comprehension_periodic_binding/comprehension_periodic_binding.air".to_string(), + ) + .transpile(Target::Winterfell) + .unwrap(); + + let expected = expect_file!["comprehension_periodic_binding/comprehension_periodic_binding.rs"]; + expected.assert_eq(&generated_air); +} + #[test] fn computed_indices_complex() { let generated_air = @@ -143,6 +157,18 @@ fn constraint_comprehension() { expected.assert_eq(&generated_air); } +#[test] +fn cross_module_constants() { + // Test that constants used in comprehension iterables work across module boundaries + let generated_air = + Test::new("src/tests/cross_module_constants/cross_module_constants.air".to_string()) + .transpile(Target::Winterfell) + .unwrap(); + + let expected = expect_file!["cross_module_constants/cross_mod_constants.rs"]; + expected.assert_eq(&generated_air); +} + #[test] fn evaluators_nested_slice_call() { let generated_air = diff --git a/codegen/plonky3/src/air/mod.rs b/codegen/plonky3/src/air/mod.rs index 32a585ce9..11788e4a8 100644 --- a/codegen/plonky3/src/air/mod.rs +++ b/codegen/plonky3/src/air/mod.rs @@ -33,7 +33,7 @@ pub(super) fn add_air(scope: &mut Scope, ir: &Air) { add_air_struct(scope, ir, name); // add the aux trace generation utils if needed - if ir.num_random_values > 0 { + if ir.num_random_values > 0 && name != "MidenVM" { add_aux_trace_utils(scope, ir, name); } } @@ -118,8 +118,8 @@ fn add_air_struct(scope: &mut Scope, ir: &Air, name: &str) { miden_air_impl.new_fn("aux_width").arg_ref_self().ret("usize").line("AUX_WIDTH"); - let bus_types_fn = miden_air_impl.new_fn("bus_types").arg_ref_self().ret("Vec"); - bus_types_fn.line("vec!["); + let bus_types_fn = miden_air_impl.new_fn("bus_types").arg_ref_self().ret("&[BusType]"); + bus_types_fn.line("&["); for (_id, bus) in &ir.buses { let bus_type_str = match bus.bus_type { air_ir::BusType::Multiset => "BusType::Multiset", @@ -131,7 +131,7 @@ fn add_air_struct(scope: &mut Scope, ir: &Air, name: &str) { } // add the build_aux_trace function if needed - if ir.num_random_values > 0 { + if ir.num_random_values > 0 && name != "MidenVM" { let build_aux_trace_func = miden_air_impl .new_fn("build_aux_trace") .arg_ref_self() diff --git a/constraints/Cargo.toml b/constraints/Cargo.toml new file mode 100644 index 000000000..2263eadd9 --- /dev/null +++ b/constraints/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "constraints" +version = "0.1.0" +edition = "2021" + +[dependencies] +air-ir = { path = "../air", version = "0.5" } +air-parser = { path = "../parser", version = "0.5" } +air-pass = { path = "../pass", version = "0.5" } +air-mir = { path = "../mir", version = "0.5" } +air-codegen-ace = { path = "../codegen/ace", version = "0.5" } +miden-diagnostics = { workspace = true } +miden-core = { package = "miden-core", version = "0.13", default-features = false } + +winter-air = { package = "winter-air", version = "0.12", default-features = false } +winter-math = { package = "winter-math", version = "0.12", default-features = false } +winter-utils = { package = "winter-utils", version = "0.12", default-features = false } +winter-prover = { package = "winter-prover", version = "0.12", default-features = false } +winter-verifier = { package = "winter-verifier", version = "0.12", default-features = false } +winterfell = { package = "winterfell", version = "0.12", default-features = false } + +[dev-dependencies] +anyhow = "1" \ No newline at end of file diff --git a/constraints/ace.air b/constraints/ace.air new file mode 100644 index 000000000..9fdafab55 --- /dev/null +++ b/constraints/ace.air @@ -0,0 +1,396 @@ +########################################################################################## +# ACE CHIPLET CONSTRAINTS MODULE +########################################################################################## +# +# The ACE (Arithmetic Circuit Evaluation) chiplet reduces the number of cycles required +# when recursively verifying a STARK proof in Miden assembly by evaluating arithmetic +# circuits and ensuring they evaluate to zero over given inputs. +# +# OVERVIEW: +# The ACE chiplet operates in two phases: +# 1. READ blocks: Load extension field elements from memory and assign node IDs +# 2. EVAL blocks: Execute arithmetic operations on previously loaded nodes +# +# Each section starts with READ operations to load inputs, followed by EVAL operations +# to compute intermediate and final results. The final result must evaluate to zero +# to represent a valid constraint satisfaction. +# +# ACE TRACE TABLE LAYOUT (16 columns): +# +# ┌─────────────┬────────────────────────────────────────────────────────────────────────────┐ +# │ Column │ Purpose │ +# ├─────────────┼────────────────────────────────────────────────────────────────────────────┤ +# │ sstart │ Section start flag (binary): 1 = first row of section, 0 = otherwise │ +# │ sblock │ Block selector (binary): 0 = READ block, 1 = EVAL block │ +# │ ctx │ Memory access context (constant throughout section) │ +# │ ptr │ Memory pointer: increments by +4 in READ, +1 in EVAL blocks │ +# │ clk │ Memory access clock cycle (constant within section) │ +# │ op │ Operation type (EVAL only): -1 = SUB, 0 = MUL, 1 = ADD │ +# │ id0 │ Result node ID: decrements by -2 in READ, -1 in EVAL │ +# │ v0_0 │ Result node value (extension field element, coefficient 0) │ +# │ v0_1 │ Result node value (extension field element, coefficient 1) │ +# │ id1 │ First operand node ID │ +# │ v1_0 │ First operand value (extension field element, coefficient 0) │ +# │ v1_1 │ First operand value (extension field element, coefficient 1) │ +# │ id2 / n_eval│ Dual use: 2nd operand node ID (EVAL) / #evaluations in section (READ) │ +# │ v2_0 │ Second operand value, coefficient 0 (EVAL only) │ +# │ v2_1 / m1 │ Dual use: 2nd operand value (EVAL) / node 1 multiplicity (READ) │ +# │ m0 │ Wire bus multiplicity for node 0 (both READ and EVAL) │ +# └─────────────┴────────────────────────────────────────────────────────────────────────────┘ +# +# STATUS: Fully implemented +# +# REFERENCES: +# - ACE Design: https://0xmiden.github.io/miden-vm/design/chiplets/ace.html +########################################################################################## + +mod ace + +use chiplets::*; +use utils::*; + +########################################################################################## +# ACE CHIPLET CONSTRAINTS +########################################################################################## + +# Enforces constraints on all rows of ACE chiplet. +ev ace_chiplet_constraints_all_rows([s3, ace[16]]) { + let sstart = ace[0]; # Section start flag + let sblock = ace[1]; # Block selector (0=READ, 1=EVAL) + let ctx = ace[2]; # Memory access context + let ptr = ace[3]; # Memory pointer + let clk = ace[4]; # Memory access clock + let op = ace[5]; # Operation type (for EVAL block) + let id0 = ace[6]; # First node identifier + let v0_0 = ace[7]; # First node value (element 0) + let v0_1 = ace[8]; # First node value (element 1) + let id1 = ace[9]; # Second node identifier + let v1_0 = ace[10]; # Second node value (element 0) + let v1_1 = ace[11]; # Second node value (element 1) + let id2 = ace[12]; # Third node identifier (EVAL only) + let n_eval = ace[12]; # Total number of arithmetic operations (READ only, same column as id2) + let v2_0 = ace[13]; # Third node value (element 0, EVAL only) + let v2_1 = ace[14]; # Third node value (element 1, EVAL only) + let m1 = ace[14]; # Multiplicity for node 1 wire bus (READ only, same column as v2_1) + let m0 = ace[15]; # Multiplicity for node 0 wire bus (both READ and EVAL) + + let flag_ace_next = flag_ace_current_and_next(s3'); + let flag_ace_last = flag_ace_last(s3'); + + #################################################################################### + # TRANSITION CONSTRAINTS + #################################################################################### + + # Section and block flags constraints + enf section_block_flags_constraints([s3, sstart, sstart', sblock, id0, n_eval]); + + # Section general constraints + enf section_constraints([sstart, sblock, ctx, ptr, clk, id0]) when flag_ace_next; + + # Section specific constraints: READ block + enf enforce_read_block_constraints([sblock, id0, id1]); + + # Section specific constraints: EVAL block + enf enforce_eval_block_constraints([sblock, op, v0_0, v0_1, v1_0, v1_1, v2_0, v2_1]); + + # Finalization constraints + let f_end = binary_or(binary_and(flag_ace_next, sstart'), flag_ace_last); + enf finalization_constraints([id0, v0_0, v0_1]) when f_end; + + #################################################################################### + # BUS RESPONSE - ACE INITIALIZATION + #################################################################################### + # The ACE chiplet provides a response to the decoder's ACE_INIT request via the + # chiplets bus. The response is sent when a new section starts (sstart = 1). + # + # Message format: (ACE_INIT, ctx, ptr, clk, nread, neval) + # where: + # - ctx, clk: Memory access context and clock cycle + # - ptr: Word-aligned pointer to first input variable + # - nread: Total count of input and constant elements (computed as id0 + 1 - neval) + # - neval: Total number of arithmetic operations + # + # Note: Since id0 = nread + neval - 1 in the first row, we have nread = id0 - neval + 1 + #################################################################################### + + # Compute nread from id0 and n_eval + # Since id0 = nread + neval - 1 in first row, then: nread = id0 - neval + 1 + let nread = id0 + 1 - n_eval; + + # Remove ACE INIT response when a section starts + bus_6_chiplets_bus.remove(ACEINIT, ctx, ptr, clk, nread, n_eval) when sstart; + #################################################################################### + # BUS REQUESTS - ACE MEMORY ACCESS + #################################################################################### + # ACE requests memory via virtual table (memory responds via bus_6_chiplets_bus). + # + # READ: word-aligned read (MEMREADWORD, ctx, ptr, clk, v0_0, v0_1, v1_0, v1_1) + # EVAL: encoded instruction (MEMREADELEMENT, ctx, ptr, clk, instruction) + # where instruction = id1 + id2 * 2^30 + (op + 1) * 2^60 + #################################################################################### + + let is_read_block = binary_not(sblock); + let is_eval_block = sblock; + + bus_5_v_table.remove(MEMREADWORD, ctx, ptr, clk, v0_0, v0_1, v1_0, v1_1) when is_read_block; + + let instruction = id1 + id2 * ACEINSTRUCTIONIDONEOFFSET + (op + 1) * ACEINSTRUCTIONIDTWOOFFSET; + bus_5_v_table.remove(MEMREADELEMENT, ctx, ptr, clk, instruction) when is_eval_block; + + #################################################################################### + # WIRE BUS + #################################################################################### + # The wire bus (bus_7_wiring_bus) ensures that every node ID used as an operand + # in EVAL blocks was previously defined in READ blocks or earlier EVAL blocks. + # + # The LogUp protocol tracks node definitions and consumptions: + # - READ blocks: Define 2 nodes (id0, id1) with multiplicities (m0, m1) + # - EVAL blocks: Consume 2 nodes (id1, id2), define 1 node (id0) with multiplicity m0 + # + # Each node is tracked with: (clk, ctx, id, v0, v1) + # + # NOTE: The VM implementation forces the wiring bus accumulator to be 0 on ACE entry/exit, + # but Air-Script can only express `null` boundary constraints for buses. There is no way + # to encode these mid-trace boundary checks here. + # The sibling virtual table has the same limitation; its constraints are expected to be redesigned. + #################################################################################### + + # READ block: Insert two nodes being loaded from memory + # Node 0: (id0, v0) with fan-out multiplicity m0 + # Node 1: (id1, v1) with fan-out multiplicity m1 + # Use conditional multiplicity: m * is_read_block (multiplicity if READ, 0 if EVAL) + let m0_read = m0 * is_read_block; + let m1_read = m1 * is_read_block; + bus_7_wiring_bus.insert(clk, ctx, id0, v0_0, v0_1) with m0_read; + bus_7_wiring_bus.insert(clk, ctx, id1, v1_0, v1_1) with m1_read; + + # EVAL block: Consume two input nodes, insert one result node + # Consume input node 1: (id1, v1) + # Consume input node 2: (id2, v2) + # Insert result node 0: (id0, v0) with fan-out multiplicity m0 + # Use conditional multiplicity: 1 * is_eval_block (consume if EVAL, 0 if READ) + let consume = is_eval_block; + let m0_eval = m0 * is_eval_block; + bus_7_wiring_bus.remove(clk, ctx, id1, v1_0, v1_1) with consume; + bus_7_wiring_bus.remove(clk, ctx, id2, v2_0, v2_1) with consume; + bus_7_wiring_bus.insert(clk, ctx, id0, v0_0, v0_1) with m0_eval; +} + +# Enforces that on the first row of ACE chiplet we should have sstart' = 1 +ev ace_chiplet_constraints_first_row([s3, ace[16]]) { + let sstart = ace[0]; # Section start flag + + enf sstart' = 1; +} + +########################################################################################## +# CONSTRAINT EVALUATORS +########################################################################################## + +# Section and block flag management +# +# This evaluator enforces the proper sequencing of ACE chiplet operations: +# - Sections must start with READ blocks and end with EVAL blocks +# - Block transitions follow valid patterns (READ→EVAL within sections) +# - Section boundaries are correctly marked with sstart flags +# - READ→EVAL transition occurs when n_eval matches id0 +ev section_block_flags_constraints([s3, sstart, sstart_next, sblock, id0, n_eval]) { + let flag_ace_next = flag_ace_current_and_next(s3'); + let flag_ace_last = flag_ace_last(s3'); + + let section_flags = section_flags(s3', sstart, sstart_next); + let f_start = section_flags[0]; + let f_next = section_flags[1]; + let f_end = section_flags[2]; + + let block_flags = block_flags(sblock); + let block_flags_next = block_flags(sblock'); + let f_read = block_flags[0]; + let f_eval = block_flags[1]; + let f_read_next = block_flags_next[0]; + let f_eval_next = block_flags_next[1]; + + # Binary constraints for section and block flags + enf enforce_binary_columns([sstart, sblock]); + + # Last row of ACE chiplet cannot be section start + enf sstart = 0 when flag_ace_last; + + # Prevent consecutive section starts within ACE chiplet + enf binary_and(sstart, sstart') = 0 when flag_ace_next; + + # Sections must start with READ blocks (not EVAL) + enf f_eval = 0 when f_start; + + # EVAL blocks cannot be followed by READ blocks within same section + enf f_read_next = 0 when binary_and(f_next, f_eval); + + # Sections must end with EVAL blocks (not READ) + enf f_read = 0 when f_end; + + # In a READ block, n_eval stays constant. + # When transitioning to an EVAL block, the next id0 must equal n_eval. + # This ensures proper sequencing: READ loads nodes with IDs, EVAL starts processing + # from the highest loaded node ID (n_eval). + enf select(f_read_next, n_eval', id0') = n_eval when f_read; +} + +# Constrains binary columns for flags and selectors +ev enforce_binary_columns([sstart, sblock]) { + # Section start flag must be binary + enf is_binary([sstart]); + + # Block selector must be binary + enf is_binary([sblock]); +} + +# Section-level constraints (common to both READ and EVAL blocks) +# +# These constraints apply throughout an entire section regardless of block type: +# - Context (ctx) and clock (clk) remain constant within a section +# - Memory pointer (ptr) increments with fixed increments: +4 in READ, +1 in EVAL +# - Node identifiers (id0) decrement with fixed decrements: -2 in READ, -1 in EVAL +ev section_constraints([sstart, sblock, ctx, ptr, clk, id0]) { + let flag_within_section = binary_not(sstart'); + let flag_read = !sblock; + let flag_eval = sblock; + + # Context consistency within a section + enf ctx' = ctx when flag_within_section; + + # Clock consistency within a section + enf clk' = clk when flag_within_section; + + # Memory pointer must decrease by 4 in READ blocks and by 1 in EVAL blocks + enf ptr' = ptr + 4 * flag_read + flag_eval when flag_within_section; + + # Node identifiers decreases by 2 in READ blocks and by 1 in EVAL blocks + enf id0 = id0' + 2 * flag_read + flag_eval when flag_within_section; +} + +# Finalization constraints (ensure final result is zero) +ev finalization_constraints([id0, v0_0, v0_1]) { + # The final result of the arithmetic circuit evaluation must be zero + # This ensures the circuit represents a valid constraint + enf v0_0 = 0; + enf v0_1 = 0; + + # Final node ID should be the root node + enf id0 = 0; +} + +# READ block operation constraints +# +# The only specific constraint to READ blocks is a constraint ensuring that the IDs of the two +# loaded extension field elements is consecutive. +ev enforce_read_block_constraints([sblock, id0, id1]) { + let is_read_block = binary_not(sblock); + + # In READ block, we read two extension field elements and assign node IDs + # The two node IDs should be consecutive. Note that the node IDs are decreasing. + enf id1 = id0 - 1 when is_read_block; +} + +# EVAL block operation constraints +# +# Enforces arithmetic circuit evaluation during EVAL operations: +# - Validates operation codes (op ∈ {-1, 0, 1} for SUB, MUL, ADD) +# - Performs extension field arithmetic on input nodes (v1, v2) +ev enforce_eval_block_constraints([sblock, op, v0_0, v0_1, v1_0, v1_1, v2_0, v2_1]) { + let is_eval_block = sblock; + + # In EVAL block, we decode instruction and perform arithmetic operation + # The 'op' column contains the operation type and must be equal to either -1, 0, or 1 + enf op * (op - 1) * (op + 1) = 0 when is_eval_block; + + # Arithmetic operation constraint based on op type + enf enforce_arithmetic_operation([op, v0_0, v0_1, v1_0, v1_1, v2_0, v2_1]) when is_eval_block; +} + + +# Arithmetic operation evaluation for EVAL block +# +# Performs extension field arithmetic based on operation code: +# - op = -1: Subtraction (v0 = v1 - v2) +# - op = 0: Multiplication (v0 = v1 × v2) +# - op = 1: Addition (v0 = v1 + v2) +# +# All arithmetic is in the quadratic extension field 𝔽ₚ[x]/(x² - 7) +ev enforce_arithmetic_operation([op, v0_0, v0_1, v1_0, v1_1, v2_0, v2_1]) { + # Decode operation and enforce arithmetic constraint for extension field elements + # Extension field elements are represented as (a_0, a_1) where element = a_0 + a_1 * α + + let linear_op = compute_linear_op(op, v1_0, v1_1, v2_0, v2_1); + let linear_op_0 = linear_op[0]; + let linear_op_1 = linear_op[1]; + + let non_linear_op = compute_non_linear_op(v1_0, v1_1, v2_0, v2_1); + let non_linear_op_0 = non_linear_op[0]; + let non_linear_op_1 = non_linear_op[1]; + + let op_square = op^2; + + enf op_square * (linear_op_0 - non_linear_op_0) + non_linear_op_0 = v0_0; + enf op_square * (linear_op_1 - non_linear_op_1) + non_linear_op_1 = v0_1; +} + +# Computes linear operations (addition and subtraction) in extension field +# - op = -1: Subtraction (v0 = v1 - v2) +# - op = 1: Addition (v0 = v1 + v2) +fn compute_linear_op(op: felt, v1_0: felt, v1_1: felt, v2_0: felt, v2_1: felt) -> felt[2] { + let res0 = v1_0 + op * v2_0; + let res1 = v1_1 + op * v2_1; + return [res0, res1]; +} + +# Multiplication in the quadratic extension field. +# +# The extension is 𝔽ₚ[x]/(x² - 7), so x² = 7 +# For (a0 + a1·x)(b0 + b1·x) mod (x² - 7): +# res0 = a0·b0 + 7·a1·b1 +# res1 = a0·b1 + a1·b0 = (a0 + a1)(b0 + b1) - a0·b0 - a1·b1 +fn compute_non_linear_op(v1_0: felt, v1_1: felt, v2_0: felt, v2_1: felt) -> felt[2] { + let a0 = v1_0; + let a1 = v1_1; + let b0 = v2_0; + let b1 = v2_1; + + let res0 = a0 * b0 + 7 * a1 * b1; + let res1 = (b0 + b1) * (a0 + a1) - a0 * b0 - a1 * b1; + + return [res0, res1]; +} + +########################################################################################## +# HELPER FUNCTIONS +########################################################################################## + +# ACE chiplet active in current row and continuing to next row +fn flag_ace_current_and_next(s3_next: felt) -> felt { + return !s3_next; +} + +# ACE chiplet active in current row but transitioning out in next row +fn flag_ace_last(s3_next: felt) -> felt { + return s3_next; +} + +# Computes section-level flags: [f_start, f_next, f_end] +fn section_flags(s3_next: felt, s_start: felt, s_start_next: felt) -> felt[3] { + let f_ace_next = flag_ace_current_and_next(s3_next); + let f_ace_last = flag_ace_last(s3_next); + + let f_start = s_start; + let f_next = !s_start_next; + let f_end = binary_or(binary_and(f_ace_next, s_start_next), f_ace_last); + + return [f_start, f_next, f_end]; +} + +# Computes block-level flags: [f_read, f_eval] +fn block_flags(s_block: felt) -> felt[2] { + let f_read = !s_block; + let f_eval = s_block; + + return [f_read, f_eval]; +} diff --git a/constraints/bitwise.air b/constraints/bitwise.air new file mode 100644 index 000000000..ce4db600e --- /dev/null +++ b/constraints/bitwise.air @@ -0,0 +1,187 @@ +########################################################################################## +# BITWISE OPERATIONS CHIPLET +########################################################################################## +# +# The Bitwise chiplet handles bitwise logical operations (AND, XOR) on 32-bit values. +# It decomposes field elements into their binary representation and performs bit-level +# operations efficiently using field arithmetic. +# +# Each bitwise operation spans exactly 8 rows, with limbs processed in little-endian order. +# +# STATUS: Fully implemented (core constraints + bus responses complete) +# +# REFERENCES: +# - Bitwise Chiplet: https://0xmiden.github.io/miden-vm/design/chiplets/bitwise.html +########################################################################################## + +mod bitwise + +use utils::*; + +########################################################################################## +# BITWISE OPERATION CONSTANTS (Periodic Columns) +########################################################################################## +# +# Periodic constants contain values needed to switch various constraints on or off. +# +periodic_columns { + k_first: [1, 0, 0, 0, 0, 0, 0, 0], + k_transition: [1, 1, 1, 1, 1, 1, 1, 0], +} + +########################################################################################## +# BITWISE CHIPLET TRANSITION CONSTRAINTS +########################################################################################## +# +# The bitwise chiplet processes 32-bit integers by decomposing them into individual +# bits, applying bitwise operations, and recomposing the results. This approach +# enables verification of bitwise logic within the field arithmetic constraint system. + +# Enforces the constraints on the bitwise chiplet given its columns. +# +# Max constraint degree: 4 +ev bitwise_chiplet_constraints([op_flag, a, b, a_limb[4], b_limb[4], zp, z]) { + #################################################################################### + # TRANSITION CONSTRAINTS + #################################################################################### + + enf bitwise_op_flag([op_flag]); + enf input_decomposition([a, b, a_limb, b_limb]); + enf output_aggregation([op_flag, a, b, a_limb, b_limb, zp, z]); + + #################################################################################### + # BUS OPERATIONS - CHIPLETS COMMUNICATION + #################################################################################### + # The bitwise chiplet provides responses to bitwise operation requests via the + # chiplets bus. Each operation spans 8 rows, and the response is removed on the + # LAST row of the cycle (when k_transition = 0). + # + # OPERATIONS: + # - BITWISEAND (label = 2): AND operation (op_flag = 0) + # - BITWISEXOR (label = 6): XOR operation (op_flag = 1) + # + # Response format: (operation_label, a, b, z) + # where a, b are 32-bit operands and z is the result. + #################################################################################### + + # Compute operation flags + let is_and = binary_not(op_flag); + let is_xor = op_flag; + + # Remove bus responses on the last row of the 8-row cycle + let is_last_row = binary_not(k_transition); + + bus_6_chiplets_bus.remove(BITWISEAND, a, b, z) when (is_and * is_last_row); + bus_6_chiplets_bus.remove(BITWISEXOR, a, b, z) when (is_xor * is_last_row); +} + +########################################################################################## +# BUS CONSTRAINTS +########################################################################################## +# +# The bitwise chiplet communicates with the stack component using the chiplets bus. +# +# MESSAGE FORMAT: +# +# Each bitwise operation message contains: +# - Operation type (AND/XOR) +# - Input operands (a, b) as 32-bit values +# - Expected result (c) +# +########################################################################################## + +########################################################################################## +# HELPERS +########################################################################################## + +### Helper evaluators ############################################################################# + +# Enforces that the bitwise operation flag is valid. +# +# Max constraint degree: 2 +ev bitwise_op_flag([op_flag]) { + # Enforce operation flag is binary (0 for AND, 1 for XOR). + # Constraint degree: 2 + enf is_binary([op_flag]); + + # Enforce operation flag should stay the same throughout the 8-row cycle. + # Constraint degree: 2 + enf op_flag' = op_flag when k_transition; +} + + +# Enforces that the input to the bitwise chiplet is decomposed into limbs correctly. +# +# Max constraint degree: 2 +ev input_decomposition([a, b, a_limb[4], b_limb[4]]) { + # Enforce that the input is decomposed into valid bits. + # Constraints degree: 2 + enf is_binary([a]) for a in a_limb; + enf is_binary([b]) for b in b_limb; + + # Enforce that the value in the first row of column `a` of the current 8-row cycle should be + # the aggregation of the decomposed bit columns `a_limb` (little-endian). + let a_aggr = aggregate_limbs(a_limb); + # Constraint degree: 2 + enf a = a_aggr when k_first; + + # Enforce that the value in the first row of column `b` of the current 8-row cycle should be + # the aggregation of the decomposed bit columns `b_limb` (little-endian). + let b_aggr = aggregate_limbs(b_limb); + # Constraint degree: 2 + enf b = b_aggr when k_first; + + # Enforce that for all rows in an 8-row cycle, except for the last one, the values in a and b + # columns are increased by the values contained in the individual bit columns a_limb and + # b_limb. + # Constraints degree: 2 + enf a' = a * 16 + a_aggr when k_transition; + enf b' = b * 16 + b_aggr when k_transition; +} + + +# Enforces that the output of the bitwise operation is aggregated correctly from the decomposed +# limbs. +# +# Max constraint degree: 3 +ev output_aggregation([op_flag, a, b, a_limb[4], b_limb[4], zp, z]) { + # Enforce that in the first row, the aggregated output value of the previous row should be 0. + # Constraint degree: 2 + enf zp = 0 when k_first; + + # Enforce that for each row except the last, the aggregated output value must equal the + # previous aggregated output value in the next row. + # Constraint degree: 2 + enf zp' = z when k_transition; + + # Enforce that for all rows the value in the z column is computed by multiplying the previous + # output value (from the zp column in the current row) by 16 and then adding it to the bitwise + # operation applied to the row's set of bits of a_limb and b_limb. The entire constraint must + # also be multiplied by the operation selector flag to ensure it is only applied for the + # appropriate operation. The constraint for AND is enforced when op_flag = 0 and the constraint for + # XOR is enforced when op_flag = 1. Because the selectors for the AND and XOR operations are mutually + # exclusive, the constraints for different operations can be aggregated into the same result + # indices. + # Constraints degree: 3 + let a_and_b = compute_limb_and(a_limb, b_limb); + let a_xor_b = compute_limb_xor(a_limb, b_limb); + + enf z = zp * 16 + op_flag * (a_xor_b - a_and_b) + a_and_b; +} + +### Helper functions ############################################################################## + +# Returns value aggregated from limbs in little-endian order. +fn aggregate_limbs(limbs: felt[4]) -> felt { + return sum([2^i * limb for (i, limb) in (0..4, limbs)]); +} + +# Computes AND operation result for a 4-bit limb using fold/reduce approach. +fn compute_limb_and(a_limb: felt[4], b_limb: felt[4]) -> felt { + return sum([2^i * binary_and(a_bit, b_bit) for (i, a_bit, b_bit) in (0..4, a_limb, b_limb)]); +} + +# Computes XOR operation result for a 4-bit limb using fold/reduce approach. +fn compute_limb_xor(a_limb: felt[4], b_limb: felt[4]) -> felt { + return sum([2^i * binary_xor(a_bit, b_bit) for (i, a_bit, b_bit) in (0..4, a_limb, b_limb)]); +} diff --git a/constraints/chiplets.air b/constraints/chiplets.air new file mode 100644 index 000000000..47daba8ff --- /dev/null +++ b/constraints/chiplets.air @@ -0,0 +1,173 @@ +########################################################################################## +# CHIPLETS CONSTRAINTS MODULE +########################################################################################## +# +# The Chiplets module contains specialized computation units that handle complex operations +# like cryptographic hashing, bitwise operations, and memory access. Each chiplet uses a +# hierarchical selector system to identify which operations are active. +# +# CHIPLETS COLUMN LAYOUT (20 columns): +# ┌─────────┬──────────────────────────────────────────────────────────────────────┐ +# │ Columns │ Purpose │ +# ├─────────┼──────────────────────────────────────────────────────────────────────┤ +# │ 0-4 │ s[5] - Hierarchical selector flags │ +# │ 5-19 │ Chiplet-specific data (hasher, bitwise ops, memory, ACE, kernel ROM) │ +# └─────────┴──────────────────────────────────────────────────────────────────────┘ +# +# STATUS: Not fully implemented +# +# REFERENCES: +# - Chiplets Design: https://0xmiden.github.io/miden-vm/design/chiplets/main.html +########################################################################################## + +mod chiplets + +use ace::ace_chiplet_constraints_all_rows; +use ace::ace_chiplet_constraints_first_row; + +use hasher::hash_chiplet; + +use bitwise::bitwise_chiplet_constraints; + +use memory::memory_chiplet_constraints_all_rows; +use memory::memory_chiplet_constraints_all_rows_except_last; +use memory::flag_memory_active_not_last_row; +use memory::flag_next_row_first_row_memory; +use memory::memory_chiplet_constraints_first_row; + +use kernel_rom::ker_rom_chiplet_constraints; +use kernel_rom::kernel_rom_chiplet_constraints_first_row; + +use utils::*; + +########################################################################################## +# CHIPLETS CONSTRAINTS +########################################################################################## + +ev chiplets_constraints([chiplets[20], system_clk]) { + # Chiplets' flag constraints + let s0 = chiplets[0]; + let s1 = chiplets[1]; + let s2 = chiplets[2]; + let s3 = chiplets[3]; + let s4 = chiplets[4]; + enf chiplet_selectors([s0, s1, s2, s3, s4]); + + # MAIN CHIPLET CONSTRAINT: + + # The chiplet system uses a hierarchical binary selector scheme where each selector + # bit (s0, s1, s2, s3, s4) determines which chiplet is active at any given row. + # + # This hierarchy ensures exactly one chiplet is active per row and provides + # deterministic transitions between chiplets based on selector state changes. + let hash_active = hasher_chiplet_flag(s0); # Active when: !s0 + let bitwise_active = bitwise_chiplet_flag(s0, s1); # Active when: s0 * !s1 + let memory_active = memory_chiplet_flag(s0, s1, s2); # Active when: s0 * s1 * !s2 + let ace_active = ace_chiplet_flag(s0, s1, s2, s3); # Active when: s0 * s1 * s2 * !s3 + let ker_rom_active = ker_rom_chiplet_flag(s0, s1, s2, s3, s4); # Active when: s0 * s1 * s2 * s3 * !s4 + + # Apply chiplet-specific constraints based on hierarchical selector state. + enf match { + case hash_active: hash_chiplet([chiplets[0..16], system_clk]), + case bitwise_active: bitwise_chiplet_constraints([chiplets[2..15]]), + case memory_active: memory_chiplet_constraints_all_rows([chiplets[3..18]]), + case ace_active: ace_chiplet_constraints_all_rows([chiplets[3..20]]), + case ker_rom_active: ker_rom_chiplet_constraints([chiplets[4..10]]), + }; + + # CHIPLET CONSTRAINTS REQUIRING SPECIAL HANDLING + + ## MEMORY + + ### The memory chiplet requires special handling for both initialization and transition constraints + ### to ensure proper memory access sequencing and state transitions. + let flag_next_row_first_row_memory = flag_next_row_first_row_memory(s0, s1, s2); # Transitioning into memory chiplet + let flag_memory_active_not_last_row = flag_memory_active_not_last_row(s0, s1, s2); # Active in memory, not exiting + + ### MEMORY INITIALIZATION CONSTRAINTS: + ### Apply specialized initialization constraints when first entering the memory chiplet. + enf memory_chiplet_constraints_first_row([chiplets[3..18]]) when flag_next_row_first_row_memory; + + ### MEMORY TRANSITION CONSTRAINTS ON ALL BUT LAST ROW: + ### Apply standard transition constraints while active in memory chiplet, excluding the final row. + enf memory_chiplet_constraints_all_rows_except_last([chiplets[3..18]]) when flag_memory_active_not_last_row; + + ## ACE + + ### Apply ACE chiplet initialization constraints at the transition point + let next_row_first_ace = memory_active * s2' * binary_not(s3'); # Transitioning into ACE chiplet + enf ace_chiplet_constraints_first_row([chiplets[3..20]]) when next_row_first_ace; + + ## KERNEL ROM + + ### The kernel ROM chiplet requires initialization constraints to ensure proper startup. + ### We force sfirst' = 1 on the first kernel ROM row, establishing proper digest initialization. + let next_row_first_kernel_rom = ace_active * s3' * binary_not(s4'); # Transitioning into kernel ROM chiplet + enf kernel_rom_chiplet_constraints_first_row([chiplets[4..10]]) when next_row_first_kernel_rom; + +} + +########################################################################################## +# CHIPLET SELECTOR SYSTEM +########################################################################################## + +# Hierarchical chiplet selector constraints +# +# CONSTRAINT DEGREE: 2 (quadratic due to binary constraints) +# +ev chiplet_selectors([s[5]]) { + #################################################################################### + # BINARY CONSTRAINTS - Ensure all selectors are valid binary values + #################################################################################### + + enf is_binary([s[0]]); + + enf is_binary([s[1]]) when s[0]; + enf is_binary([s[2]]) when s[0] & s[1]; + enf is_binary([s[3]]) when s[0] & s[1] & s[2]; + enf is_binary([s[4]]) when s[0] & s[1] & s[2] & s[3]; + + #################################################################################### + # STABILITY CONSTRAINTS - Prevent deactivation (forbids 1→0 transitions) + #################################################################################### + + # Once a selector level becomes active (1), it must remain active + # This ensures chiplet operations maintain consistent state throughout execution + enf s[0]' = s[0] when s[0]; + enf s[1]' = s[1] when s[0] & s[1]; + enf s[2]' = s[2] when s[0] & s[1] & s[2]; + enf s[3]' = s[3] when s[0] & s[1] & s[2] & s[3]; + enf s[4]' = s[4] when s[0] & s[1] & s[2] & s[3] & s[4]; +} + +########################################################################################## +# CHIPLET ACTIVATION FUNCTIONS +########################################################################################## + +# These functions decode the hierarchical selector pattern to identify active chiplets. +# Each chiplet activates when its selector pattern matches and the next level is inactive. + +# Hasher chiplet: Active when root selector is inactive +fn hasher_chiplet_flag(s_0: felt) -> felt { + return !s_0; +} + +# Bitwise chiplet: Active when s0=1, s1=0 +fn bitwise_chiplet_flag(s_0: felt, s_1: felt) -> felt { + return s_0 * !s_1; +} + +# Memory chiplet: Active when s0=1, s1=1, s2=0 +fn memory_chiplet_flag(s_0: felt, s_1: felt, s_2: felt) -> felt { + return s_0 * s_1 * !s_2; +} + +# ACE chiplet: Active when s0=1, s1=1, s2=1, s3=0 +fn ace_chiplet_flag(s_0: felt, s_1: felt, s_2: felt, s_3: felt) -> felt { + return s_0 * s_1 * s_2 * !s_3; +} + +# Kernel ROM chiplet: Active when s0=1, s1=1, s2=1, s3=1, s4=0 +fn ker_rom_chiplet_flag(s_0: felt, s_1: felt, s_2: felt, s_3: felt, s_4: felt) -> felt { + return s_0 * s_1 * s_2 * s_3 * !s_4; +} diff --git a/constraints/decoder.air b/constraints/decoder.air new file mode 100644 index 000000000..95de8f0f5 --- /dev/null +++ b/constraints/decoder.air @@ -0,0 +1,1244 @@ +########################################################################################## +# MIDEN VM - PROGRAM DECODER CONSTRAINTS +########################################################################################## +# +# This module implements the decoder constraints from the Miden VM specification: +# https://0xmiden.github.io/miden-vm/design/decoder/main.html +# +########################################################################################## + +mod decoder + +use utils::*; + +########################################################################################## +# DECODER TRACE LAYOUT +########################################################################################## +# +# The decoder trace consists of 24 columns organized into logical registers: +# +# Block Address Registers (1 column): +# - addr: Address of current block's hasher (unique block identifier) +# +# Opcode Registers (7 columns): +# - b0-b6: Binary registers encoding individual opcode bits +# +# Hasher Registers (8 columns): +# - h0-h7: Hash computations and operation-specific helper variables +# +# Execution State Registers (3 columns): +# - sp: Binary flag indicating execution inside a basic block +# - gc: Tracks unprocessed operation groups in current basic block +# - ox: Tracks current operation's index within operation group +# +# Operation Batch Flags (3 columns): +# - c0, c1, c2: Indicate number of operation groups in a batch +# +# Additional Registers (2 columns): +# - e0, e1: Extra registers for constraint degree reduction +# +########################################################################################## + +# Main decoder constraint evaluator +# Note: Decoder needs access to: +# - stack top (s0-s2) for operation constraints and general constraints +# - system clk/ctx for bus operations +# - frame pointer (fmp) and overflow registers (stack_b0, stack_b1) for block stack table +# - function hash (fn_hash[0..3]) for CALL/SYSCALL/DYNCALL operations +ev decoder([addr, b0, b1, b2, b3, b4, b5, b6, h0, h1, h2, h3, h4, h5, h6, h7, sp, gc, ox, c0, c1, c2, e0, e1, s0, s1, s2, system_clk, system_ctx, fmp, stack_b0, stack_b1, fn_hash_0, fn_hash_1, fn_hash_2, fn_hash_3]) { + #################################################################################### + # TRANSITION CONSTRAINTS + #################################################################################### + + # GENERAL DECODER CONSTRAINTS + enf general_constraints([b0, b1, b2, b3, b4, b5, b6, e0, e1, h0, h1, h2, h3, h4, h5, h6, h7, addr, sp, s0]); + + # BASIC BLOCK CONSTRAINTS + enf basic_block_constraints([b0, b1, b2, b3, b4, b5, b6, e0, e1, h0, h1, h2, h3, h4, h5, h6, h7, addr, sp, gc, ox]); + + # OPERATION BATCH FLAGS CONSTRAINTS + enf op_batch_flags_constraints([b0, b1, b2, b3, b4, b5, b6, e0, e1, h0, h1, h2, h3, h4, h5, h6, h7, c0, c1, c2]); + + # OP FLAGS BITS CONSTRAINTS + enf u32_bit_constraints([b0, b1, b2, b3, b4, b5, b6]); + enf high_degree_bit_constraints([b0, b1, b2, b3, b4, b5, b6, e0]); + enf very_high_degree_bit_constraints([b0, b1, b2, b3, b4, b5, b6, e1]); + + #################################################################################### + # BUS OPERATIONS - CHIPLETS COMMUNICATION + #################################################################################### + + # Compute operation flags once for all bus operations + let fdyn = flag_dyn([b0, b1, b2, b3, b4, b5, b6], e0); + let fdyncall = flag_dyncall([b0, b1, b2, b3, b4, b5, b6], e0); + let fsyscall = flag_syscall([b0, b1, b2, b3, b4, b5, b6], e1); + let fevalcircuit = flag_evalcircuit([b0, b1, b2, b3, b4, b5, b6], e0); + let flogprecompile = flag_logprecompile([b0, b1, b2, b3, b4, b5, b6], e0); + let fspan = flag_span([b0, b1, b2, b3, b4, b5, b6], e0); + let frespan = flag_respan([b0, b1, b2, b3, b4, b5, b6], e1); + let fend = flag_end([b0, b1, b2, b3, b4, b5, b6], e1); + let fjoin = flag_join([b0, b1, b2, b3, b4, b5, b6], e0); + let fsplit = flag_split([b0, b1, b2, b3, b4, b5, b6], e0); + let floop = flag_loop([b0, b1, b2, b3, b4, b5, b6], e0); + let fcall = flag_call([b0, b1, b2, b3, b4, b5, b6], e1); + + # Opcode value for domain separation: d = Σ(bi·2^i) + let opcode = b0 + 2 * b1 + 4 * b2 + 8 * b3 + 16 * b4 + 32 * b5 + 64 * b6; + + # DYN/DYNCALL: Read target hash from memory (h0-h3) and hash zeros to compute block hash + bus_6_chiplets_bus.insert(MEMREADWORD, system_ctx, s0, system_clk, h0, h1, h2, h3) when (fdyn + fdyncall); + bus_6_chiplets_bus.insert(HASHERLINEARHASH, addr', 0, 0, 0, 0, 0, 0, 0, 0) when (fdyn + fdyncall); + + # Kernel ROM: SYSCALL validates kernel procedure and computes block hash + # SYSCALL hashes: hash_control_block(kernel_proc_hash, EMPTY_WORD, domain, digest) + # The kernel procedure hash is in h0-h3, second child is zeros (no second child) + bus_6_chiplets_bus.insert(KERNELPROCCALL, h0, h1, h2, h3) when fsyscall; + bus_6_chiplets_bus.insert(HASHERLINEARHASH, addr', h0, h1, h2, h3, 0, 0, 0, 0, opcode) when fsyscall; + + # ACE chiplet: EVALCIRCUIT initializes arithmetic circuit evaluation + # Stack layout for EVALCIRCUIT: [ptr, nread, neval, ...] + # Message format: (ACE_INIT, ctx, ptr, clk, nread, neval) + let ace_ptr = s0; # Memory pointer to first input variable (word-aligned) + let ace_nread = s1; # Number of input and constant elements + let ace_neval = s2; # Number of arithmetic operations + bus_6_chiplets_bus.insert(ACEINIT, system_ctx, ace_ptr, system_clk, ace_nread, ace_neval) when fevalcircuit; + + # SPAN/RESPAN/END: Basic block hashing operations + bus_6_chiplets_bus.insert(HASHERLINEARHASH, addr', h0, h1, h2, h3, h4, h5, h6, h7) when fspan; + bus_6_chiplets_bus.insert(HASHERLINEARHASH, addr', h0, h1, h2, h3, h4, h5, h6, h7) when frespan; + bus_6_chiplets_bus.insert(HASHERRETURNHASH, addr + 7, h0, h1, h2, h3) when fend; + + # Control flow with opcode domain separation: JOIN/SPLIT/LOOP/CALL + # JOIN/SPLIT hash two children: hash_control_block(child1, child2, domain, digest) + bus_6_chiplets_bus.insert(HASHERLINEARHASH, addr', h0, h1, h2, h3, h4, h5, h6, h7, opcode) when fjoin; + bus_6_chiplets_bus.insert(HASHERLINEARHASH, addr', h0, h1, h2, h3, h4, h5, h6, h7, opcode) when fsplit; + # LOOP/CALL hash one child + zeros: hash_control_block(child, EMPTY_WORD, domain, digest) + bus_6_chiplets_bus.insert(HASHERLINEARHASH, addr', h0, h1, h2, h3, 0, 0, 0, 0, opcode) when floop; + bus_6_chiplets_bus.insert(HASHERLINEARHASH, addr', h0, h1, h2, h3, 0, 0, 0, 0, opcode) when fcall; + + #################################################################################### + # BUS OPERATIONS - DECODER VIRTUAL TABLES + #################################################################################### + + #################################################################################### + # BUS 0: BLOCK STACK TABLE (bus_0_decoder_p1) + #################################################################################### + # Tracks block execution contexts during control flow. + # Format: (blk_id, parent_id, is_loop, ctx, fmp, b0, b1, fn_hash[0..3]) + # Context fields (ctx, fmp, b0, b1, fn_hash) are populated only for CALL/SYSCALL. + #################################################################################### + + # JOIN/SPLIT/SPAN/DYN: Simple control flow without context + bus_0_decoder_p1.insert(addr', addr, 0, 0, 0, 0, 0, 0, 0, 0, 0) when fjoin; + bus_0_decoder_p1.insert(addr', addr, 0, 0, 0, 0, 0, 0, 0, 0, 0) when fsplit; + bus_0_decoder_p1.insert(addr', addr, 0, 0, 0, 0, 0, 0, 0, 0, 0) when fspan; + bus_0_decoder_p1.insert(addr', addr, 0, 0, 0, 0, 0, 0, 0, 0, 0) when fdyn; + + # LOOP: is_loop flag equals stack top + bus_0_decoder_p1.insert(addr', addr, s0, 0, 0, 0, 0, 0, 0, 0, 0) when floop; + + # RESPAN: Update parent block ID + bus_0_decoder_p1.remove(addr, h1', 0, 0, 0, 0, 0, 0, 0, 0, 0) when frespan; + bus_0_decoder_p1.insert(addr', h1', 0, 0, 0, 0, 0, 0, 0, 0, 0) when frespan; + + # CALL/SYSCALL: Save execution context + bus_0_decoder_p1.insert(addr', addr, 0, system_ctx, fmp, stack_b0, stack_b1, h0, h1, h2, h3) when fcall; + bus_0_decoder_p1.insert(addr', addr, 0, system_ctx, fmp, stack_b0, stack_b1, h0, h1, h2, h3) when fsyscall; + + # DYNCALL: Save context with h4/h5 (post-shift stack state) + bus_0_decoder_p1.insert(addr', addr, 0, system_ctx, fmp, h4, h5, fn_hash_0, fn_hash_1, fn_hash_2, fn_hash_3) when fdyncall; + + # END: Remove block from stack (restore context if call/syscall) + let is_call_or_syscall = h6 + h7; + let is_simple_end = 1 - is_call_or_syscall; + bus_0_decoder_p1.remove(addr, h1', is_call_or_syscall * h5, h2', h3', h4', h5', h0', h1', h2', h3') when fend * is_call_or_syscall; + bus_0_decoder_p1.remove(addr, h1', 0, 0, 0, 0, 0, 0, 0, 0, 0) when fend * is_simple_end; + + #################################################################################### + # BUS 1: BLOCK HASH TABLE (bus_1_decoder_p2) + #################################################################################### + # Tracks parent-child relationships in control flow. + # Format: (parent_id, child_hash[0..3], is_first_child, is_loop_body) + #################################################################################### + + # JOIN: Insert both children (parent is next row's address) + bus_1_decoder_p2.insert(addr', h0, h1, h2, h3, 1, 0) when fjoin; + bus_1_decoder_p2.insert(addr', h4, h5, h6, h7, 0, 0) when fjoin; + + # SPLIT: Insert selected branch based on s0 + let split_h0 = s0 * h0 + (1 - s0) * h4; + let split_h1 = s0 * h1 + (1 - s0) * h5; + let split_h2 = s0 * h2 + (1 - s0) * h6; + let split_h3 = s0 * h3 + (1 - s0) * h7; + bus_1_decoder_p2.insert(addr', split_h0, split_h1, split_h2, split_h3, 0, 0) when fsplit; + + # LOOP: Insert loop body only if s0=1 + bus_1_decoder_p2.insert(addr', h0, h1, h2, h3, 0, 1) when floop * s0; + + # REPEAT: Insert loop body for re-execution + let frepeat = flag_repeat([b0, b1, b2, b3, b4, b5, b6], e1); + bus_1_decoder_p2.insert(addr', h0, h1, h2, h3, 0, 1) when frepeat; + + # DYN/DYNCALL/CALL/SYSCALL: Insert callee hash + bus_1_decoder_p2.insert(addr', h0, h1, h2, h3, 0, 0) when fdyn; + bus_1_decoder_p2.insert(addr', h0, h1, h2, h3, 0, 0) when fdyncall; + bus_1_decoder_p2.insert(addr', h0, h1, h2, h3, 0, 0) when fcall; + bus_1_decoder_p2.insert(addr', h0, h1, h2, h3, 0, 0) when fsyscall; + bus_1_decoder_p2.insert(addr', h0, h1, h2, h3, 0, 0) when flogprecompile; + + # END: Remove child hash. + # is_first_child = 1 when next op is NOT {END, REPEAT, HALT} + let fend_next = flag_end([b0', b1', b2', b3', b4', b5', b6'], e1'); + let frepeat_next = flag_repeat([b0', b1', b2', b3', b4', b5', b6'], e1'); + let fhalt_next = flag_halt([b0', b1', b2', b3', b4', b5', b6'], e1'); + let is_first_child = 1 - (fend_next + frepeat_next + fhalt_next); + let is_loop_body = h4; + bus_1_decoder_p2.remove(addr', h0, h1, h2, h3, is_first_child, is_loop_body) when fend; + + #################################################################################### + # BUS 2: OP GROUP TABLE (bus_2_decoder_p3) + #################################################################################### + # Tracks operation groups during basic block execution. + # Note: h0 is decoded immediately, only h1-h7 are inserted. + #################################################################################### + + # Batch size flags + let fg1 = (1 - c0) * c1 * (1 - c2); + let fg2 = (1 - c0) * (1 - c1) * c2; + let fg4 = (1 - c0) * c1 * c2; + let fg8 = c0; + + # 2-group batch: Insert h1 + bus_2_decoder_p3.insert(addr', gc - 1, h1) when (fspan + frespan) * fg2; + + # 4-group batch: Insert h1-h3 + bus_2_decoder_p3.insert(addr', gc - 1, h1) when (fspan + frespan) * fg4; + bus_2_decoder_p3.insert(addr', gc - 2, h2) when (fspan + frespan) * fg4; + bus_2_decoder_p3.insert(addr', gc - 3, h3) when (fspan + frespan) * fg4; + + # 8-group batch: Insert h1-h7 + bus_2_decoder_p3.insert(addr', gc - 1, h1) when (fspan + frespan) * fg8; + bus_2_decoder_p3.insert(addr', gc - 2, h2) when (fspan + frespan) * fg8; + bus_2_decoder_p3.insert(addr', gc - 3, h3) when (fspan + frespan) * fg8; + bus_2_decoder_p3.insert(addr', gc - 4, h4) when (fspan + frespan) * fg8; + bus_2_decoder_p3.insert(addr', gc - 5, h5) when (fspan + frespan) * fg8; + bus_2_decoder_p3.insert(addr', gc - 6, h6) when (fspan + frespan) * fg8; + bus_2_decoder_p3.insert(addr', gc - 7, h7) when (fspan + frespan) * fg8; + + # Remove group when decoding (PUSH uses s0' as immediate value) + let fpush = flag_push([b0, b1, b2, b3, b4, b5, b6], e0); + let op_next = b0' + 2 * b1' + 4 * b2' + 8 * b3' + 16 * b4' + 32 * b5' + 64 * b6'; + let decoded_op_value = (h0' * 2^7 + op_next) * (1 - fpush) + s0' * fpush; + let is_decrementing_gc = sp * (gc - gc'); + bus_2_decoder_p3.remove(addr, gc, decoded_op_value) when is_decrementing_gc; +} + +########################################################################################## +# GENERAL DECODER CONSTRAINTS EVALUATOR +########################################################################################## +# Reference: https://0xmiden.github.io/miden-vm/design/decoder/constraints.html#general-constraints +# +# All 10 general decoder constraints consolidated into a single evaluator for efficiency. +# This allows computing operation flags once and reusing them across all constraints. +# +ev general_constraints([b0, b1, b2, b3, b4, b5, b6, e0, e1, h0, h1, h2, h3, h4, h5, h6, h7, addr, sp, s0]) { + # Compute all required operation flags once + let fsplit = flag_split([b0, b1, b2, b3, b4, b5, b6], e0); + let floop = flag_loop([b0, b1, b2, b3, b4, b5, b6], e0); + let fdyn = flag_dyn([b0, b1, b2, b3, b4, b5, b6], e0); + let frepeat = flag_repeat([b0, b1, b2, b3, b4, b5, b6], e1); + let frespan = flag_respan([b0, b1, b2, b3, b4, b5, b6], e1); + let fend = flag_end([b0, b1, b2, b3, b4, b5, b6], e1); + let fhalt = flag_halt([b0, b1, b2, b3, b4, b5, b6], e1); + let fctrl = flag_ctrl([b0, b1, b2, b3, b4, b5, b6], e0, e1); + + # 1. SPLIT/LOOP Binary Constraint (degree 7) + # Ensures top of stack is binary (0 or 1) when executing SPLIT or LOOP operations + let fsplit_loop = fsplit + floop; + enf is_binary([s0]) when fsplit_loop; + + # 2. DYN Hasher Zero Constraint (degree 6) + # DYN uses h0..h3 for the callee digest; only h4..h7 must be zero. + enf h4 = 0 when fdyn; + enf h5 = 0 when fdyn; + enf h6 = 0 when fdyn; + enf h7 = 0 when fdyn; + + # 3. REPEAT Top-of-Stack Constraint (degree 5) + # Ensures top of stack is 1 during REPEAT operation + enf s0 = 1 when frepeat; + + # 4. REPEAT Loop Body Constraint (degree 5) + # Ensures REPEAT operation occurs inside a loop (h4 must be 1) + enf h4 = 1 when frepeat; + + # 5. RESPAN Block ID Increment Constraint (degree 5) + # Block address incremented by 8 during RESPAN + enf addr' = addr + 8 when frespan; + + # 6. END Loop Exit Constraint (degree 6) + # Ensures top of stack is 0 when exiting a loop via END (when h5 = 1) + let is_loop = h5; + enf s0 = 0 when fend & is_loop; + + # 7. END-REPEAT State Preservation Constraint (degree 9) + # Copies block hash and loop body flag during END-REPEAT transition + # Formula: fend * frepeat' * (hi' - hi) = 0 for i ∈ [0, 5) + let frepeat_next = flag_repeat([b0', b1', b2', b3', b4', b5', b6'], e1'); + let fend_frepeat_next = fend * frepeat_next; + enf h0' = h0 when fend_frepeat_next; + enf h1' = h1 when fend_frepeat_next; + enf h2' = h2 when fend_frepeat_next; + enf h3' = h3 when fend_frepeat_next; + enf h4' = h4 when fend_frepeat_next; + + # 8. HALT Instruction Sequence Constraint (degree 8) + # Ensures HALT is followed only by HALT + # Formula: fhalt * (1 - fhalt') = 0 + let fhalt_next = flag_halt([b0', b1', b2', b3', b4', b5', b6'], e1'); + enf fhalt * (1 - fhalt_next) = 0; + + # 9. HALT Block Address Constraint (degree 5) + # When HALT operation is executed, block address must be 0 + enf addr = 0 when fhalt; + + # 10. Each operation bit must be 0 or 1 (binary constraint) + enf is_binary([b0]) = 0; + enf is_binary([b1]) = 0; + enf is_binary([b2]) = 0; + enf is_binary([b3]) = 0; + enf is_binary([b4]) = 0; + enf is_binary([b5]) = 0; + enf is_binary([b6]) = 0; + + # 11. In-Span and Control Flow Constraint (degree 5) + # When sp = 1 (inside basic block), no control flow ops can execute + # When sp = 0 (outside basic block), only control flow ops can execute + enf fctrl = 1 - sp; +} + +########################################################################################## +# BASIC BLOCK CONSTRAINTS EVALUATOR +########################################################################################## +# Reference: https://0xmiden.github.io/miden-vm/design/decoder/constraints.html#basic-block +# +# Consolidated constraints for basic block execution including: +# - In-span column (sp): Binary flag for basic block execution state +# - Block address (addr): Block identifier consistency +# - Group count (gc): Operation group tracking +# - Op group decoding (h0): Operation group extraction +# - Op index (ox): Operation position within group +# +ev basic_block_constraints([b0, b1, b2, b3, b4, b5, b6, e0, e1, h0, h1, h2, h3, h4, h5, h6, h7, addr, sp, gc, ox]) { + # Compute all required operation flags once for efficiency + let fspan = flag_span([b0, b1, b2, b3, b4, b5, b6], e0); + let frespan = flag_respan([b0, b1, b2, b3, b4, b5, b6], e1); + let fend = flag_end([b0, b1, b2, b3, b4, b5, b6], e1); + let fimm = flag_imm([b0, b1, b2, b3, b4, b5, b6], e0); + + # Compute next-row operation flags + let fend_next = flag_end([b0', b1', b2', b3', b4', b5', b6'], e1'); + let frespan_next = flag_respan([b0', b1', b2', b3', b4', b5', b6'], e1'); + + # Compute helper values used across multiple constraints + let delta_gc = gc - gc'; # Group count decrement (0 or 1) + let delta_ox = ox' - ox; # Op index change + + # Compute opcode for next row: op' = Σ(bi' * 2^i) for i = 0 to 6 + let op_next = b0' + 2 * b1' + 4 * b2' + 8 * b3' + 16 * b4' + 32 * b5' + 64 * b6'; + + # ================================================================================== + # IN-SPAN COLUMN CONSTRAINTS (3 constraints) + # Reference: https://0xmiden.github.io/miden-vm/design/decoder/constraints.html#in-span-column-constraints + # ================================================================================== + + # 1. sp is binary + enf is_binary([sp]) = 0; + + # 2. When executing SPAN or RESPAN, next sp must be set to 1 (degree 6) + enf sp' = 1 when (fspan + frespan); + + # ================================================================================== + # BLOCK ADDRESS CONSTRAINTS (1 constraint) + # Reference: https://0xmiden.github.io/miden-vm/design/decoder/constraints.html#block-address-constraints + # ================================================================================== + + # 4. When inside basic block, block address must remain the same (degree 2) + enf addr' = addr when sp; + + # ================================================================================== + # GROUP COUNT CONSTRAINTS (5 constraints) + # Reference: https://0xmiden.github.io/miden-vm/design/decoder/constraints.html#group-count-constraints + # ================================================================================== + + # 5. Inside basic block, gc can stay same or decrease by 1 (degree 3) + enf sp * delta_gc * (delta_gc - 1) = 0; + + # 6. When gc decrements in a span, either h0 is 0 or immediate value op is executed (degree 8) + enf sp * delta_gc * (1 - fimm) * h0 = 0; + + # 7. During SPAN, RESPAN, or immediate value ops, gc must decrement by 1 (degree 6) + enf (fspan + frespan + fimm) * (delta_gc - 1) = 0; + + # 8. If next operation is END or RESPAN, gc must remain same (degree 5) + enf delta_gc * (fend_next + frespan_next) = 0; + + # 9. When END operation is executed, gc must be 0 (degree 5) + enf gc = 0 when fend; + + # ================================================================================== + # OP GROUP DECODING CONSTRAINTS (2 constraints) + # Reference: https://0xmiden.github.io/miden-vm/design/decoder/constraints.html#op-group-decoding-constraints + # ================================================================================== + + # Special group count flag: fsgc = sp * sp' * (1 - Δgc) + let fsgc = sp * sp' * (1 - delta_gc); + + # 10. When span/respan/immediate ops occur or gc doesn't change, h0 decrements by op' (degree 6) + # Note: Using 2^7 (128) as the radix since operations are 7-bit values (0-127) + enf h0 = h0' * 2^7 + op_next when fspan + frespan + fimm + fsgc; + + # 11. When in basic block and next op is END or RESPAN, h0 must be zero (degree 6) + enf h0 = 0 when sp * (fend_next + frespan_next); + + # ================================================================================== + # OP INDEX CONSTRAINTS (4 constraints) + # Reference: https://0xmiden.github.io/miden-vm/design/decoder/constraints.html#op-index-constraints + # ================================================================================== + + # New group flag: ng = Δgc - fimm (ignore immediate-value groups) + let ng = delta_gc - fimm; + + # 12. When executing SPAN or RESPAN, next ox must be set to 0 (degree 6) + enf ox' = 0 when fspan + frespan; + + # 13. When starting new operation group inside basic block, next ox must be 0 (degree 6) + enf ox' = 0 when sp & ng; + + # 14. When inside basic block but not starting new group, ox must increment by 1 (degree 7) + enf delta_ox = 1 when sp * sp' * (1 - ng); + + # 15. Op index must be in range [0, 8] (degree 9) + # Product constraint: Π(ox - i) for i = 0 to 8 + enf ox * (ox - 1) * (ox - 2) * (ox - 3) * (ox - 4) * (ox - 5) * (ox - 6) * (ox - 7) * (ox - 8) = 0; +} + +########################################################################################## +# OPERATION BATCH FLAGS CONSTRAINTS EVALUATOR +########################################################################################## +# Reference: https://0xmiden.github.io/miden-vm/design/decoder/constraints.html#op-batch-flags-constraints +# +# Operation batch flags (c0, c1, c2) indicate the number of operation groups in a batch. +# The specification uses bc0, bc1, bc2 as column names, but the trace uses c0, c1, c2. +# +ev op_batch_flags_constraints([b0, b1, b2, b3, b4, b5, b6, e0, e1, h0, h1, h2, h3, h4, h5, h6, h7, c0, c1, c2]) { + # Compute required operation flags + let fspan = flag_span([b0, b1, b2, b3, b4, b5, b6], e0); + let frespan = flag_respan([b0, b1, b2, b3, b4, b5, b6], e1); + + # Compute batch group flags (trace encodings) + let fg8 = c0; # 8 groups (c0=1) + let fg4 = (1 - c0) * c1 * (1 - c2); # 4 groups (c0=0, c1=1, c2=0) + let fg2 = (1 - c0) * (1 - c1) * c2; # 2 groups (c0=0, c1=0, c2=1) + let fg1 = (1 - c0) * c1 * c2; # 1 group (c0=0, c1=1, c2=1) + + # ================================================================================== + # BATCH FLAG CONSTRAINTS (6 constraints) + # ================================================================================== + + # 1-3. Batch flags must be binary (degree 2 each) + enf is_binary([c0]) = 0; + enf is_binary([c1]) = 0; + enf is_binary([c2]) = 0; + + # 4. When SPAN or RESPAN executed, exactly one batch flag must be set (degree 5) + enf (fspan + frespan) - (fg1 + fg2 + fg4 + fg8) = 0; + + # 5. When not executing SPAN or RESPAN, all batch flags must be zero (degree 6) + enf (1 - (fspan + frespan)) * (c0 + c1 + c2) = 0; + + # 6. For batches with ≤4 groups, higher registers h4-h7 must be zero (degree 4 each) + let fg1_2_4 = fg1 + fg2 + fg4; + enf h4 = 0 when fg1_2_4; + enf h5 = 0 when fg1_2_4; + enf h6 = 0 when fg1_2_4; + enf h7 = 0 when fg1_2_4; + + # 7. For batches with ≤2 groups, registers h2-h3 must be zero (degree 4 each) + let fg1_2 = fg1 + fg2; + enf h2 = 0 when fg1_2; + enf h3 = 0 when fg1_2; + + # 8. For single-group batches, register h1 must be zero (degree 4) + enf h1 = 0 when fg1; +} + +########################################################################################## +# OP FLAG BITS CONSTRAINTS EVALUATOR +########################################################################################## + +# U32 operations constraint: Force b0 = 0 for all u32 operations +# This ensures u32 opcodes always end with 0: 100_xxx0 +ev u32_bit_constraints([b0, b1, b2, b3, b4, b5, b6]) { + let f_u32_group = b6 * (1 - b5) * (1 - b4); + enf b0 = 0 when f_u32_group; +} + +# High-degree operations constraint: e0 = b6 * (1 - b5) * b4 +# This defines the degree reduction for 101 group operations +ev high_degree_bit_constraints([b0, b1, b2, b3, b4, b5, b6, e0]) { + enf e0 = b6 * (1 - b5) * b4; +} + +# Very high-degree operations constraints: Multiple constraints for 110/111 groups +# These enforce degree reduction and force last 2 bits to 0 +ev very_high_degree_bit_constraints([b0, b1, b2, b3, b4, b5, b6, e1]) { + # Degree reduction: e1 = b6 * b5 + enf e1 = b6 * b5; + + # Force last 2 bits to 0 for very high-degree operations + enf b0 = 0 when e1; + enf b1 = 0 when e1; +} + +########################################################################################## +# SYSTEMATIC OPERATION FLAG FUNCTIONS - INDIVIDUAL FLAGS PER OP +########################################################################################## + +########################################################################################## +# NO STACK SHIFT OPERATIONS (000 group) - 16 operations +########################################################################################## + +fn flag_noop(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_eqz(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]) * (1 - bits[1]) * bits[0]; +} + +fn flag_neg(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]) * bits[1] * (1 - bits[0]); +} + +fn flag_inv(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]) * bits[1] * bits[0]; +} + +fn flag_incr(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * bits[2] * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_not(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * bits[2] * (1 - bits[1]) * bits[0]; +} + +fn flag_mload(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * bits[2] * bits[1] * bits[0]; +} + +fn flag_swap(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * bits[3] * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_caller(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * bits[3] * (1 - bits[2]) * (1 - bits[1]) * bits[0]; +} + +fn flag_movup2(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * bits[3] * (1 - bits[2]) * bits[1] * (1 - bits[0]); +} + +fn flag_movdn2(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * bits[3] * (1 - bits[2]) * bits[1] * bits[0]; +} + +fn flag_movup3(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * bits[3] * bits[2] * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_movdn3(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * bits[3] * bits[2] * (1 - bits[1]) * bits[0]; +} + +fn flag_advpopw(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * bits[3] * bits[2] * bits[1] * (1 - bits[0]); +} + +fn flag_expacc(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * (1 - bits[4]) * bits[3] * bits[2] * bits[1] * bits[0]; +} + +########################################################################################## +# NO-SHIFT OPERATIONS (001 group) - 15 operations +########################################################################################## + +fn flag_movup4(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * (1 - bits[3]) * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_movdn4(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * (1 - bits[3]) * (1 - bits[2]) * (1 - bits[1]) * bits[0]; +} + +fn flag_movup5(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * (1 - bits[3]) * (1 - bits[2]) * bits[1] * (1 - bits[0]); +} + +fn flag_movdn5(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * (1 - bits[3]) * (1 - bits[2]) * bits[1] * bits[0]; +} + +fn flag_movup6(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * (1 - bits[3]) * bits[2] * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_movdn6(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * (1 - bits[3]) * bits[2] * (1 - bits[1]) * bits[0]; +} + +fn flag_movup7(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * (1 - bits[3]) * bits[2] * bits[1] * (1 - bits[0]); +} + +fn flag_movdn7(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * (1 - bits[3]) * bits[2] * bits[1] * bits[0]; +} + +fn flag_swapw(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * bits[3] * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_ext2mul(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * bits[3] * (1 - bits[2]) * (1 - bits[1]) * bits[0]; +} + +fn flag_movup8(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * bits[3] * (1 - bits[2]) * bits[1] * (1 - bits[0]); +} + +fn flag_movdn8(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * bits[3] * (1 - bits[2]) * bits[1] * bits[0]; +} + +fn flag_swapw2(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * bits[3] * bits[2] * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_swapw3(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * bits[3] * bits[2] * (1 - bits[1]) * bits[0]; +} + +fn flag_swapdw(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * bits[3] * bits[2] * bits[1] * (1 - bits[0]); +} + +fn flag_emit(bits: felt[7]) -> felt { + return (1 - bits[6]) * (1 - bits[5]) * bits[4] * bits[3] * bits[2] * bits[1] * bits[0]; +} + +########################################################################################## +# LEFT STACK SHIFT OPERATIONS (010 group) - 16 operations +########################################################################################## + +fn flag_assert(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_eq(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]) * (1 - bits[1]) * bits[0]; +} + +fn flag_add(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]) * bits[1] * (1 - bits[0]); +} + +fn flag_mul(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]) * bits[1] * bits[0]; +} + +fn flag_and(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * (1 - bits[3]) * bits[2] * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_or(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * (1 - bits[3]) * bits[2] * (1 - bits[1]) * bits[0]; +} + +fn flag_u32and(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * (1 - bits[3]) * bits[2] * bits[1] * (1 - bits[0]); +} + +fn flag_u32xor(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * (1 - bits[3]) * bits[2] * bits[1] * bits[0]; +} + +fn flag_frie2f4(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * bits[3] * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_drop(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * bits[3] * (1 - bits[2]) * (1 - bits[1]) * bits[0]; +} + +fn flag_cswap(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * bits[3] * (1 - bits[2]) * bits[1] * (1 - bits[0]); +} + +fn flag_cswapw(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * bits[3] * (1 - bits[2]) * bits[1] * bits[0]; +} + +fn flag_mloadw(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * bits[3] * bits[2] * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_mstore(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * bits[3] * bits[2] * (1 - bits[1]) * bits[0]; +} + +fn flag_mstorew(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * (1 - bits[4]) * bits[3] * bits[2] * bits[1] * (1 - bits[0]); +} + +########################################################################################## +# RIGHT STACK SHIFT OPERATIONS (011 group) - 16 operations +########################################################################################## + +fn flag_pad(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * (1 - bits[3]) * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_dup(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * (1 - bits[3]) * (1 - bits[2]) * (1 - bits[1]) * bits[0]; +} + +fn flag_dup1(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * (1 - bits[3]) * (1 - bits[2]) * bits[1] * (1 - bits[0]); +} + +fn flag_dup2(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * (1 - bits[3]) * (1 - bits[2]) * bits[1] * bits[0]; +} + +fn flag_dup3(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * (1 - bits[3]) * bits[2] * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_dup4(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * (1 - bits[3]) * bits[2] * (1 - bits[1]) * bits[0]; +} + +fn flag_dup5(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * (1 - bits[3]) * bits[2] * bits[1] * (1 - bits[0]); +} + +fn flag_dup6(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * (1 - bits[3]) * bits[2] * bits[1] * bits[0]; +} + +fn flag_dup7(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * bits[3] * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_dup9(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * bits[3] * (1 - bits[2]) * (1 - bits[1]) * bits[0]; +} + +fn flag_dup11(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * bits[3] * (1 - bits[2]) * bits[1] * (1 - bits[0]); +} + +fn flag_dup13(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * bits[3] * (1 - bits[2]) * bits[1] * bits[0]; +} + +fn flag_dup15(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * bits[3] * bits[2] * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_advpop(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * bits[3] * bits[2] * (1 - bits[1]) * bits[0]; +} + + +fn flag_sdepth(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * bits[3] * bits[2] * bits[1] * (1 - bits[0]); +} + +fn flag_clk(bits: felt[7]) -> felt { + return (1 - bits[6]) * bits[5] * bits[4] * bits[3] * bits[2] * bits[1] * bits[0]; +} + +########################################################################################## +# U32 OPERATIONS (100 group) - 8 operations +########################################################################################## + +fn flag_u32add(bits: felt[7]) -> felt { + return bits[6] * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_u32sub(bits: felt[7]) -> felt { + return bits[6] * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]) * bits[1] * (1 - bits[0]); +} + +fn flag_u32mul(bits: felt[7]) -> felt { + return bits[6] * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * bits[2] * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_u32div(bits: felt[7]) -> felt { + return bits[6] * (1 - bits[5]) * (1 - bits[4]) * (1 - bits[3]) * bits[2] * bits[1] * (1 - bits[0]); +} + +fn flag_u32split(bits: felt[7]) -> felt { + return bits[6] * (1 - bits[5]) * (1 - bits[4]) * bits[3] * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_u32assert2(bits: felt[7]) -> felt { + return bits[6] * (1 - bits[5]) * (1 - bits[4]) * bits[3] * (1 - bits[2]) * bits[1] * (1 - bits[0]); +} + +fn flag_u32add3(bits: felt[7]) -> felt { + return bits[6] * (1 - bits[5]) * (1 - bits[4]) * bits[3] * bits[2] * (1 - bits[1]) * (1 - bits[0]); +} + +fn flag_u32madd(bits: felt[7]) -> felt { + return bits[6] * (1 - bits[5]) * (1 - bits[4]) * bits[3] * bits[2] * bits[1] * (1 - bits[0]); +} + +########################################################################################## +# HIGH-DEGREE OPERATIONS (101 group) - 16 operations +# These operations use e0 for degree reduction: op_flag = f_101 * f_xxxx = e0 * f_xxxx +########################################################################################## + +fn flag_hperm(bits: felt[7], e0: felt) -> felt { + return e0 * f_x0000(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_mpverify(bits: felt[7], e0: felt) -> felt { + return e0 * f_x0001(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_pipe(bits: felt[7], e0: felt) -> felt { + return e0 * f_x0010(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_mstream(bits: felt[7], e0: felt) -> felt { + return e0 * f_x0011(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_split(bits: felt[7], e0: felt) -> felt { + return e0 * f_x0100(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_loop(bits: felt[7], e0: felt) -> felt { + return e0 * f_x0101(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_span(bits: felt[7], e0: felt) -> felt { + return e0 * f_x0110(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_join(bits: felt[7], e0: felt) -> felt { + return e0 * f_x0111(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_dyn(bits: felt[7], e0: felt) -> felt { + return e0 * f_x1000(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_hornerbase(bits: felt[7], e0: felt) -> felt { + return e0 * f_x1001(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_hornerext(bits: felt[7], e0: felt) -> felt { + return e0 * f_x1010(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_push(bits: felt[7], e0: felt) -> felt { + return e0 * f_x1011(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_dyncall(bits: felt[7], e0: felt) -> felt { + return e0 * f_x1100(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_evalcircuit(bits: felt[7], e0: felt) -> felt { + return e0 * f_x1101(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_logprecompile(bits: felt[7], e0: felt) -> felt { + return e0 * f_x1110(bits[3], bits[2], bits[1], bits[0]); +} + +fn flag_op101_1111(bits: felt[7], e0: felt) -> felt { + return e0 * f_x1111(bits[3], bits[2], bits[1], bits[0]); +} + +########################################################################################## +# VERY HIGH-DEGREE OPERATIONS (110 and 111 groups) - 8 operations +# These operations use e1 for degree reduction and last 2 bits must be 0 +########################################################################################## + +fn flag_mrupdate(bits: felt[7], e1: felt) -> felt { + return e1 * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]); # 110_0000, last 2 bits forced to 0 +} + +fn flag_cryptostream(bits: felt[7], e1: felt) -> felt { + return e1 * (1 - bits[4]) * bits[3] * (1 - bits[2]); # 110_0100, last 2 bits forced to 0 +} + +fn flag_syscall(bits: felt[7], e1: felt) -> felt { + return e1 * bits[4] * (1 - bits[3]) * (1 - bits[2]); # 110_1000, last 2 bits forced to 0 +} + +fn flag_call(bits: felt[7], e1: felt) -> felt { + return e1 * bits[4] * bits[3] * (1 - bits[2]); # 110_1100, last 2 bits forced to 0 +} + +fn flag_end(bits: felt[7], e1: felt) -> felt { + return e1 * bits[4] * (1 - bits[3]) * (1 - bits[2]); # 111_0000, last 2 bits forced to 0 +} + +fn flag_repeat(bits: felt[7], e1: felt) -> felt { + return e1 * bits[4] * (1 - bits[3]) * bits[2]; # 111_0100, last 2 bits forced to 0 +} + +fn flag_respan(bits: felt[7], e1: felt) -> felt { + return e1 * bits[4] * bits[3] * (1 - bits[2]); # 111_1000, last 2 bits forced to 0 +} + +fn flag_halt(bits: felt[7], e1: felt) -> felt { + return e1 * bits[4] * bits[3] * bits[2]; # 111_1100, last 2 bits forced to 0 +} + +########################################################################################## +# COMPOSITE FLAGS - SYSTEMATIC FUNCTIONS +########################################################################################## + +# Helper functions for the first 3 bits (b6, b5, b4) - systematic bit pattern matching +fn f_000(b6: felt, b5: felt, b4: felt) -> felt { + return (1 - b6) * (1 - b5) * (1 - b4); +} + +fn f_001(b6: felt, b5: felt, b4: felt) -> felt { + return (1 - b6) * (1 - b5) * b4; +} + +fn f_010(b6: felt, b5: felt, b4: felt) -> felt { + return (1 - b6) * b5 * (1 - b4); +} + +fn f_011(b6: felt, b5: felt, b4: felt) -> felt { + return (1 - b6) * b5 * b4; +} + +fn f_u32rc(b6: felt, b5: felt, b4: felt) -> felt { + return b6 * (1 - b5) * (1 - b4); +} + +fn f_101(b6: felt, b5: felt, b4: felt) -> felt { + return b6 * (1 - b5) * b4; +} + +fn f_110(b6: felt, b5: felt, b4: felt) -> felt { + return b6 * b5 * (1 - b4); +} + +fn f_111(b6: felt, b5: felt, b4: felt) -> felt { + return b6 * b5 * b4; +} + +# Helper functions for the last 4 bits (b3, b2, b1, b0) +fn f_x0000(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return (1 - b3) * (1 - b2) * (1 - b1) * (1 - b0); +} + +fn f_x0001(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return (1 - b3) * (1 - b2) * (1 - b1) * b0; +} + +fn f_x0010(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return (1 - b3) * (1 - b2) * b1 * (1 - b0); +} + +fn f_x0011(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return (1 - b3) * (1 - b2) * b1 * b0; +} + +fn f_x0100(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return (1 - b3) * b2 * (1 - b1) * (1 - b0); +} + +fn f_x0101(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return (1 - b3) * b2 * (1 - b1) * b0; +} + +fn f_x0110(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return (1 - b3) * b2 * b1 * (1 - b0); +} + +fn f_x0111(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return (1 - b3) * b2 * b1 * b0; +} + +fn f_x1000(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return b3 * (1 - b2) * (1 - b1) * (1 - b0); +} + +fn f_x1001(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return b3 * (1 - b2) * (1 - b1) * b0; +} + +fn f_x1010(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return b3 * (1 - b2) * b1 * (1 - b0); +} + +fn f_x1011(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return b3 * (1 - b2) * b1 * b0; +} + +fn f_x1100(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return b3 * b2 * (1 - b1) * (1 - b0); +} + +fn f_x1101(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return b3 * b2 * (1 - b1) * b0; +} + +fn f_x1110(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return b3 * b2 * b1 * (1 - b0); +} + +fn f_x1111(b3: felt, b2: felt, b1: felt, b0: felt) -> felt { + return b3 * b2 * b1 * b0; +} + +########################################################################################## +# ALL-IN-ONE OPERATION FLAGS COMPUTATION - ALL 96 MIDEN VM OPERATIONS IN ONE GO +########################################################################################## + +# Complete operation flags computation - computes all 96 Miden VM operation flags +# This function computes all individual operation flags including high-degree and very high-degree operations +# This will be used in the future in order to optimize op flags computation +fn compute_all_operation_flags(bits: felt[7], e0: felt, e1: felt) -> felt[96] { + # Use helper functions for bit patterns + let f_000_val = f_000(bits[6], bits[5], bits[4]); + let f_001_val = f_001(bits[6], bits[5], bits[4]); + let f_010_val = f_010(bits[6], bits[5], bits[4]); + let f_011_val = f_011(bits[6], bits[5], bits[4]); + let f_u32rc_val = f_u32rc(bits[6], bits[5], bits[4]); + let f_101_val = f_101(bits[6], bits[5], bits[4]); + let f_110_val = f_110(bits[6], bits[5], bits[4]); + let f_111_val = f_111(bits[6], bits[5], bits[4]); + + # Helper bit patterns for last 4 bits using existing helper functions + let f_x0000_val = f_x0000(bits[3], bits[2], bits[1], bits[0]); + let f_x0001_val = f_x0001(bits[3], bits[2], bits[1], bits[0]); + let f_x0010_val = f_x0010(bits[3], bits[2], bits[1], bits[0]); + let f_x0011_val = f_x0011(bits[3], bits[2], bits[1], bits[0]); + let f_x0100_val = f_x0100(bits[3], bits[2], bits[1], bits[0]); + let f_x0101_val = f_x0101(bits[3], bits[2], bits[1], bits[0]); + let f_x0110_val = f_x0110(bits[3], bits[2], bits[1], bits[0]); + let f_x0111_val = f_x0111(bits[3], bits[2], bits[1], bits[0]); + let f_x1000_val = f_x1000(bits[3], bits[2], bits[1], bits[0]); + let f_x1001_val = f_x1001(bits[3], bits[2], bits[1], bits[0]); + let f_x1010_val = f_x1010(bits[3], bits[2], bits[1], bits[0]); + let f_x1011_val = f_x1011(bits[3], bits[2], bits[1], bits[0]); + let f_x1100_val = f_x1100(bits[3], bits[2], bits[1], bits[0]); + let f_x1101_val = f_x1101(bits[3], bits[2], bits[1], bits[0]); + let f_x1110_val = f_x1110(bits[3], bits[2], bits[1], bits[0]); + let f_x1111_val = f_x1111(bits[3], bits[2], bits[1], bits[0]); + + + # Return all 96 operation flags as felt[96] array + return [ + # No stack shift operations (000 group) - 16 operations + f_000_val * f_x0000_val, # op_noop + f_000_val * f_x0001_val, # op_eqz + f_000_val * f_x0010_val, # op_neg + f_000_val * f_x0011_val, # op_inv + f_000_val * f_x0100_val, # op_incr + f_000_val * f_x0101_val, # op_not + 0, # unused + f_000_val * f_x0111_val, # op_mload + f_000_val * f_x1000_val, # op_swap + f_000_val * f_x1001_val, # op_caller + f_000_val * f_x1010_val, # op_movup2 + f_000_val * f_x1011_val, # op_movdn2 + f_000_val * f_x1100_val, # op_movup3 + f_000_val * f_x1101_val, # op_movdn3 + f_000_val * f_x1110_val, # op_advpop1 + f_000_val * f_x1111_val, # op_expacc + + # More no-shift operations (001 group) - 16 operations + f_001_val * f_x0000_val, # op_movup4 + f_001_val * f_x0001_val, # op_movdn4 + f_001_val * f_x0010_val, # op_movup5 + f_001_val * f_x0011_val, # op_movdn5 + f_001_val * f_x0100_val, # op_movup6 + f_001_val * f_x0101_val, # op_movdn6 + f_001_val * f_x0110_val, # op_movup7 + f_001_val * f_x0111_val, # op_movdn7 + f_001_val * f_x1000_val, # op_swapw + f_001_val * f_x1001_val, # op_ext2mul + f_001_val * f_x1010_val, # op_movup8 + f_001_val * f_x1011_val, # op_movdn8 + f_001_val * f_x1100_val, # op_swapw2 + f_001_val * f_x1101_val, # op_swapw3 + f_001_val * f_x1110_val, # op_swapdw + f_001_val * f_x1111_val, # op_emit + + # Left stack shift operations (010 group) - 16 operations + f_010_val * f_x0000_val, # op_assert + f_010_val * f_x0001_val, # op_eq + f_010_val * f_x0010_val, # op_add + f_010_val * f_x0011_val, # op_mul + f_010_val * f_x0100_val, # op_and + f_010_val * f_x0101_val, # op_or + f_010_val * f_x0110_val, # op_u32and + f_010_val * f_x0111_val, # op_u32xor + f_010_val * f_x1000_val, # op_frie2f4 + f_010_val * f_x1001_val, # op_drop + f_010_val * f_x1010_val, # op_cswap + f_010_val * f_x1011_val, # op_cswapw + f_010_val * f_x1100_val, # op_mloadw + f_010_val * f_x1101_val, # op_mstore + f_010_val * f_x1110_val, # op_mstorew + 0, # unused + + # Right stack shift operations (011 group) - 16 operations + f_011_val * f_x0000_val, # op_pad + f_011_val * f_x0001_val, # op_dup + f_011_val * f_x0010_val, # op_dup1 + f_011_val * f_x0011_val, # op_dup2 + f_011_val * f_x0100_val, # op_dup3 + f_011_val * f_x0101_val, # op_dup4 + f_011_val * f_x0110_val, # op_dup5 + f_011_val * f_x0111_val, # op_dup6 + f_011_val * f_x1000_val, # op_dup7 + f_011_val * f_x1001_val, # op_dup9 + f_011_val * f_x1010_val, # op_dup11 + f_011_val * f_x1011_val, # op_dup13 + f_011_val * f_x1100_val, # op_dup15 + f_011_val * f_x1101_val, # op_advpop2 + f_011_val * f_x1110_val, # op_sdepth + f_011_val * f_x1111_val, # op_clk + + # u32 operations (100 group) - 8 operations + f_u32rc_val * f_x0000_val, # op_u32add + f_u32rc_val * f_x0010_val, # op_u32sub + f_u32rc_val * f_x0100_val, # op_u32mul + f_u32rc_val * f_x0110_val, # op_u32div + f_u32rc_val * f_x1000_val, # op_u32split + f_u32rc_val * f_x1010_val, # op_u32assert2 + f_u32rc_val * f_x1100_val, # op_u32add3 + f_u32rc_val * f_x1110_val, # op_u32madd + + # High-degree operations (101 group) - 16 operations + e0 * f_x0000_val, # op_hperm + e0 * f_x0001_val, # op_mpverify + e0 * f_x0010_val, # op_pipe + e0 * f_x0011_val, # op_mstream + e0 * f_x0100_val, # op_split + e0 * f_x0101_val, # op_loop + e0 * f_x0110_val, # op_span + e0 * f_x0111_val, # op_join + e0 * f_x1000_val, # op_dyn + e0 * f_x1001_val, # op_hornerbase + e0 * f_x1010_val, # op_hornerext + e0 * f_x1011_val, # op_push (high-degree) + e0 * f_x1100_val, # op_dyncall + e0 * f_x1101_val, # op_evalcircuit + e0 * f_x1110_val, # op_logprecompile + e0 * f_x1111_val, # op_101_1111 (unused) + + # Very high-degree operations (110/111 groups) - 8 operations + e1 * (1 - bits[4]) * (1 - bits[3]) * (1 - bits[2]), # op_mrupdate (110_0000) + e1 * (1 - bits[4]) * bits[3] * (1 - bits[2]), # op_cryptostream (110_0100) + e1 * bits[4] * (1 - bits[3]) * (1 - bits[2]), # op_syscall (110_1000) + e1 * bits[4] * bits[3] * (1 - bits[2]), # op_call (110_1100) + e1 * bits[4] * (1 - bits[3]) * (1 - bits[2]), # op_end (111_0000) + e1 * bits[4] * (1 - bits[3]) * bits[2], # op_repeat (111_0100) + e1 * bits[4] * bits[3] * (1 - bits[2]), # op_respan (111_1000) + e1 * bits[4] * bits[3] * bits[2] # op_halt (111_1100) + ]; +} + +########################################################################################## +# STACK FLAG HELPER FUNCTIONS +########################################################################################## +# +# These helper functions compute the composite fctrl, fshl and fshr flags +# Reference: https://0xmiden.github.io/miden-vm/design/stack/op_constraints.html#composite-flags +# +########################################################################################## + +# Right-Shift Flag: fshr = (1−b6)⋅b5⋅b4 + fu32split + fpush (degree 6) +fn flag_shr(bits: felt[7], e0: felt, e1: felt) -> felt { + # Base right shift pattern: (1−b6)⋅b5⋅b4 + let fshr_base = (1 - bits[6]) * bits[5] * bits[4]; + + # u32split flag: causes right shift (splits one element into two) + let fu32split = flag_u32split(bits); + + # Push operations flag: fpush = e0 * b3 * (1-b2) * b1 * b0 (opcode 91: 101_1011) + let fpush = e0 * bits[3] * (1 - bits[2]) * bits[1] * bits[0]; + + return fshr_base + fu32split + fpush; +} + +# Left-Shift Flag: fshl = (1−b6)⋅b5⋅(1−b4) + fadd3_madd + fsplit_loop + fdyn + frepeat + fend⋅h5 (degree 5) +# Note: DYNCALL performs a left shift but is excluded here because its overflow handling +# uses the decoder hasher state instead of the standard stack overflow columns. +fn flag_shl(bits: felt[7], h5: felt, e0: felt, e1: felt) -> felt { + # Base left shift pattern: (1−b6)⋅b5⋅(1−b4) + let fshl_base = (1 - bits[6]) * bits[5] * (1 - bits[4]); + + # fadd3_madd: u32add3 and u32madd operations + let fadd3_madd = bits[6] * (1 - bits[5]) * (1 - bits[4]) * bits[3] * bits[2]; + + # fsplit_loop: SPLIT and LOOP operations (101 group with specific pattern) + let fsplit_loop = e0 * (1 - bits[3]) * bits[2] * (1 - bits[1]); + + # fdyn: DYN operation (opcode 88: 101_1000) + let fdyn = flag_dyn(bits, e0); + + # frepeat: REPEAT operation (opcode 116: 111_0100) + let frepeat = e1 * bits[4] * (1 - bits[3]) * bits[2]; + + # fend⋅h5: END operation with h5 helper bit + let fend = e1 * bits[4] * (1 - bits[3]) * (1 - bits[2]); + let fend_h5 = fend * h5; + + return fshl_base + fadd3_madd + fsplit_loop + fdyn + frepeat + fend_h5; +} + +# Control Flow Flag: fctrl = fspan,join,split,loop + fend,repeat,respan,halt + fdyn + fdyncall + fcall + fsyscall (degree 5) +fn flag_ctrl(bits: felt[7], e0: felt, e1: felt) -> felt { + # fspan,join,split,loop: High-degree control flow ops with pattern e0⋅(1−b3)⋅b2 + let fspan_join_split_loop = e0 * (1 - bits[3]) * bits[2]; + + # fend,repeat,respan,halt: Very high-degree control flow ops with pattern e1⋅b4 + let fend_repeat_respan_halt = e1 * bits[4]; + + # fdyn: DYN operation (opcode 88: 101_1000) + let fdyn = e0 * bits[3] * (1 - bits[2]) * (1 - bits[1]) * (1 - bits[0]); + + # fdyncall: DYNCALL operation (opcode 92: 101_1100) + let fdyncall = e0 * f_x1100(bits[3], bits[2], bits[1], bits[0]); + + # fcall: CALL operation (opcode 108: 110_1100) + let fcall = e1 * bits[4] * bits[3] * (1 - bits[2]); + + # fsyscall: SYSCALL operation (opcode 104: 110_1000) + let fsyscall = e1 * bits[4] * (1 - bits[3]) * (1 - bits[2]); + + return fspan_join_split_loop + fend_repeat_respan_halt + fdyn + fdyncall + fcall + fsyscall; +} + +# Immediate Value Flag: fimm = fpush (degree 5) +fn flag_imm(bits: felt[7], e0: felt) -> felt { + # fpush: PUSH operation (opcode 91: 101_1011) + return e0 * bits[3] * (1 - bits[2]) * bits[1] * bits[0]; +} diff --git a/constraints/hasher.air b/constraints/hasher.air new file mode 100644 index 000000000..b000e1d56 --- /dev/null +++ b/constraints/hasher.air @@ -0,0 +1,421 @@ +########################################################################################## +# HASHER CONSTRAINTS MODULE +########################################################################################## +# +# The Hasher module is responsible for all hash-related operations, which includes: +# +# 1. A single permutation of Rescue Prime Optimized (RPO). +# 2. A simple 2-to-1 hash. +# 3. A linear hash of n field elements. +# 4. Merkle path verification. +# 5. Merkle root update. +# +# STATUS: Fully implemented (includes bus interactions) +# +# REFERENCES: +# - Hasher chiplet design: https://0xmiden.github.io/miden-vm/design/chiplets/hasher.html +########################################################################################## + +mod hasher + +use utils::*; +use rpo::enforce_rpo_round; + +########################################################################################## +# HASHER CHIPLET TRANSITION CONSTRAINTS +########################################################################################## + +# Enforces the constraints on the hash chiplet given its columns. +# +# NOTE: system_clk parameter is required for proper bus message timing. +# The hasher chiplet needs the system clock to construct bus messages that match +# the requests from the decoder/stack components. +ev hash_chiplet([s[3], h[12], i, system_clk]) { + #################################################################################### + # TRANSITION CONSTRAINTS + #################################################################################### + + # Selector columns constraints + enf selector_columns([s]); + + # Node index constraints + enf node_index([s, i]); + + # Hasher state constraints + enf hasher_state([s, h, i]); + + #################################################################################### + # BUS OPERATIONS + #################################################################################### + # The hasher chiplet provides responses to hash operation requests via the chiplets + # bus. All bus messages are sent on row 7 of the 8-row cycle (cycle_row_7 = 1). + # + # OPERATIONS: + # - HASHERLINEARHASH (label = 3): BP/ABP operations + # * BP: Begin permutation (cycle_row_0, sends all 12 state elements) + # * ABP: Absorb for linear hash (cycle_row_7, sends 8 newly absorbed rate elements) + # - HASHERRETURNHASH (label = 1): Hash output (4-element digest, h[0..3]) + # - HASHERRETURNSTATE (label = 9): State output (all 12 elements) + # - HASHERMPVERIFY (label = 11): Merkle path verification + # - HASHERMRUPDATEOLD (label = 7): Merkle root update (old path) + # - HASHERMRUPDATENEW (label = 15): Merkle root update (new path) + # + # Note: MPA/MVA/MUA (Merkle absorb) operations do not send bus messages + #################################################################################### + + # Destructure hasher state array into individual elements due to some limitations in bus syntax + let h0 = h[0]; + let h1 = h[1]; + let h2 = h[2]; + let h3 = h[3]; + let h4 = h[4]; + let h5 = h[5]; + let h6 = h[6]; + let h7 = h[7]; + let h8 = h[8]; + let h9 = h[9]; + let h10 = h[10]; + let h11 = h[11]; + + # BP: Begin Permutation operation + # Initiates single permutation, 2-to-1 hash, or linear hash computation + # Flag: f_bp = (1,0,0) on cycle_row_0 + # Message format: (operation_label, clk+1, node_index, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11) + # Sends the entire hasher state (all 12 elements) + let f_bp = get_f_bp(s, cycle_row_0); + bus_6_chiplets_bus.remove(HASHERLINEARHASH, system_clk + 1, i, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11) when f_bp; + + # ABP: Absorb for linear hash operation + # Absorbs new elements into hasher state during linear hash computation + # Flag: f_abp = (1,0,0) on cycle_row_7 + # Message format: (operation_label, clk+1, node_index, 0, 0, 0, 0, h0', h1', h2', h3', h4', h5', h6', h7') + # Sends the newly absorbed 8 elements (overwrite-mode, not add-mode) + # The capacity portion (h[8..11]) is preserved unchanged via transition constraints + let f_abp = get_f_abp(s, cycle_row_7); + bus_6_chiplets_bus.remove(HASHERLINEARHASH, system_clk + 1, i, 0, 0, 0, 0, h0', h1', h2', h3', h4', h5', h6', h7') when f_abp; + + # HOUT: Hash Output operation + # Returns the 4-element hash result (h0, h1, h2, h3) + # Flag: f_hout = (0,0,0) on cycle_row_7 + # Message format: (operation_label, clk+1, node_index, 0, 0, 0, 0, h0, h1, h2, h3, 0, 0, 0, 0) + let f_hout = get_f_hout(s, cycle_row_7); + bus_6_chiplets_bus.remove(HASHERRETURNHASH, system_clk + 1, i, 0, 0, 0, 0, h0, h1, h2, h3, 0, 0, 0, 0) when f_hout; + + # SOUT: State Output operation + # Returns the entire 12-element hasher state + # Flag: f_sout = (0,0,1) on cycle_row_7 + # Message format: (operation_label, clk+1, node_index, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11) + let f_sout = get_f_sout(s, cycle_row_7); + bus_6_chiplets_bus.remove(HASHERRETURNSTATE, system_clk + 1, i, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11) when f_sout; + + # MP, MV, MU: Merkle Path verification operations + # These operations return the leaf value selected based on bit b (LSB of node index). + # The leaf is either from rate0 h[0..3] (when b=0) or rate1 h[4..7] (when b=1). + # + # Message format per documentation: vleaf = vh + (1-b)·vb + b·vd + # where: + # vh = header with (operation_label, row_addr, node_index) + # vb = (h0, h1, h2, h3) - rate0 word of hasher state + # vd = (h4, h5, h6, h7) - rate1 word of hasher state + # + # Flags: f_mp = (1,0,1), f_mv = (1,1,0), f_mu = (1,1,1) on cycle_row_0 + # + # Reference: https://0xmiden.github.io/miden-vm/design/chiplets/hasher.html#chiplets-bus-constraints + + let f_mp = get_f_mp(s, cycle_row_0); + let f_mv = get_f_mv(s, cycle_row_0); + let f_mu = get_f_mu(s, cycle_row_0); + + # Compute bit b (LSB of node index) = i - 2*i' + # This is the bit shifted out when dividing node index by 2 + let b = i - 2 * i'; + + # Selector flags for leaf position + let is_b_zero = binary_not(b); # When b=0, leaf is in rate0 (h[0..3]) + let is_b_one = b; # When b=1, leaf is in rate1 (h[4..7]) + + # MP: Merkle Path verification - send leaf value based on bit b + # When b=0: send (clk+1, node_index, 0,0,0,0, h0,h1,h2,h3, 0,0,0,0) + # When b=1: send (clk+1, node_index, 0,0,0,0, h4,h5,h6,h7, 0,0,0,0) + bus_6_chiplets_bus.remove(HASHERMPVERIFY, system_clk + 1, i, 0, 0, 0, 0, h0, h1, h2, h3, 0, 0, 0, 0) when f_mp * is_b_zero; + bus_6_chiplets_bus.remove(HASHERMPVERIFY, system_clk + 1, i, 0, 0, 0, 0, h4, h5, h6, h7, 0, 0, 0, 0) when f_mp * is_b_one; + + # MV: Merkle root update (old path) - send leaf value based on bit b + bus_6_chiplets_bus.remove(HASHERMRUPDATEOLD, system_clk + 1, i, 0, 0, 0, 0, h0, h1, h2, h3, 0, 0, 0, 0) when f_mv * is_b_zero; + bus_6_chiplets_bus.remove(HASHERMRUPDATEOLD, system_clk + 1, i, 0, 0, 0, 0, h4, h5, h6, h7, 0, 0, 0, 0) when f_mv * is_b_one; + + # MU: Merkle root update (new path) - send leaf value based on bit b + bus_6_chiplets_bus.remove(HASHERMRUPDATENEW, system_clk + 1, i, 0, 0, 0, 0, h0, h1, h2, h3, 0, 0, 0, 0) when f_mu * is_b_zero; + bus_6_chiplets_bus.remove(HASHERMRUPDATENEW, system_clk + 1, i, 0, 0, 0, 0, h4, h5, h6, h7, 0, 0, 0, 0) when f_mu * is_b_one; + + #################################################################################### + # VIRTUAL TABLE SIBLING SHARING + #################################################################################### + # The virtual table ensures identical sibling nodes are used when verifying both + # old and new Merkle paths during root updates: + # - MV (old path): INSERT siblings into virtual table + # - MU (new path): REMOVE siblings from virtual table (must match insertions) + # + # Sibling location based on LSB of node index (bit b): + # - b=0: sibling in rate1 h[4..7] | b=1: sibling in rate0 h[0..3] + # + # Message format: (node_index, sibling[0..3]) + #################################################################################### + + # Compute absorption flags (on cycle_row_7) + let f_mva = get_f_mva(s, cycle_row_7); + let f_mua = get_f_mua(s, cycle_row_7); + + # MV: INSERT siblings during OLD path verification (cycle_row_0 and cycle_row_7) + bus_5_v_table.insert(i, h4, h5, h6, h7) when f_mv * is_b_zero; + bus_5_v_table.insert(i, h0, h1, h2, h3) when f_mv * is_b_one; + bus_5_v_table.insert(i, h4', h5', h6', h7') when f_mva * is_b_zero; + bus_5_v_table.insert(i, h0', h1', h2', h3') when f_mva * is_b_one; + + # MU: REMOVE siblings during NEW path verification (cycle_row_0 and cycle_row_7) + bus_5_v_table.remove(i, h4, h5, h6, h7) when f_mu * is_b_zero; + bus_5_v_table.remove(i, h0, h1, h2, h3) when f_mu * is_b_one; + bus_5_v_table.remove(i, h4', h5', h6', h7') when f_mua * is_b_zero; + bus_5_v_table.remove(i, h0', h1', h2', h3') when f_mua * is_b_one; +} + +########################################################################################## +# HELPER EVALUATORS +########################################################################################## + +# Enforce selector columns constraints +ev selector_columns([s[3]]) { + # Enforce that selector columns are binary. + enf is_binary([selector]) for selector in s; + + # Compute relevant flags (passing periodic column values as parameters) + let f_abp = get_f_abp(s, cycle_row_7); + let f_mpa = get_f_mpa(s, cycle_row_7); + let f_mva = get_f_mva(s, cycle_row_7); + let f_mua = get_f_mua(s, cycle_row_7); + let f_out = get_f_out(s, cycle_row_7); + let f_out_next = get_f_out_next(s, cycle_row_6, s[0]', s[1]'); + + # Enforce that unless f_out = 1 or f_out' = 1, the values in columns s[1] and s[2] are copied + # over to the next row. + # This encodes the fact that we can change the op flags only at the end of a cycle in order + # to output a result, or at the start of a new cycle to initiate a new operation. + enf is_unchanged([s[1]]) when !f_out & !f_out_next; + enf is_unchanged([s[2]]) when !f_out & !f_out_next; + + # Flag that is true when the performed operation is one of the operations represented by flags + # f_abp, f_mpa, f_mva or f_mua + let f_comp = f_abp + f_mpa + f_mva + f_mua; + + # Enforce that if any of f_abp, f_mpa, f_mva, f_mua flags is set to 1, the next value of s[0] + # is 0. + # This basically enforces the exclusion of all op which initiate a new op (at the start of a new + # cycle). Note that f_comp is a flag that is set only on rows which are 1 less than a multiple of 8 + # and hence the following constrains the 0-th selector at the start of a new cycle. + enf s[0]' = 0 when f_comp; + + # Enforce that no invalid combinations of flags are allowed. + # This enforces that if s[0] is 0 then the either f_hout or f_sout is set. + enf s[1] = 0 when binary_and(cycle_row_7, binary_not(s[0])); +} + +# Enforce node index constraints +ev node_index([s[3], i]) { + # Compute relevant flags (passing periodic column values as parameters) + let f_mp = get_f_mp(s, cycle_row_0); + let f_mv = get_f_mv(s, cycle_row_0); + let f_mu = get_f_mu(s, cycle_row_0); + let f_mpa = get_f_mpa(s, cycle_row_7); + let f_mva = get_f_mva(s, cycle_row_7); + let f_mua = get_f_mua(s, cycle_row_7); + let f_out = get_f_out(s, cycle_row_7); + + # Flag indicating to enforce the constraint that b is binary only when a new node is absorbed into + # the hasher state (when the hash operation is either one of Merkle path verification or + # Merkle root update) + let f_an = f_mp + f_mv + f_mu + f_mpa + f_mva + f_mua; + + # b is the value of the bit which is discarded during shift by one bit to the right. + let b = i - 2 * i'; + + # Enforce that b is binary only when a new node is absorbed into the hasher state. + enf b^2 - b = 0 when f_an; + + # Enforce that when a computation is finished i = 0. + enf i = 0 when f_out; + + # Enforce that the value in i is copied over to the next row unless we are absorbing a new row + # or the computation is finished. + let not_absorbing_nor_comp_finished = 1 - (f_an + f_out); + enf is_unchanged([i]) when not_absorbing_nor_comp_finished; +} + +# Enforce hasher state constraints +ev hasher_state([s[3], h[12], i]) { + # Enforce the RPO permutation round constraints + enf enforce_rpo_round([h]) when !cycle_row_7; + + # Compute relevant flags (passing periodic column values as parameters) + let f_mpa = get_f_mpa(s, cycle_row_7); + let f_mva = get_f_mva(s, cycle_row_7); + let f_mua = get_f_mua(s, cycle_row_7); + let f_abp = get_f_abp(s, cycle_row_7); + + # Flag that is true when absorbing the next node during Merkle path computation on cycle_row_7. + # NOTE: We use f_mpa/f_mva/f_mua (absorption flags) NOT f_mp/f_mv/f_mu (initialization flags) + # because these constraints apply on the last row of the cycle (cycle_row_7). + let f_absorb_node = f_mpa + f_mva + f_mua; + + # b is the value of the bit which is discarded during shift by one bit to the right. + let b = i - 2 * i'; + + # Enforce that when absorbing the next set of elements during linear hash computation on cycle_row_7 + # (i.e. f_abp = 1), the capacity portion (h[8..11]) is carried over to the next row. + # This implements overwrite-mode where only the rate portion (h[0..7]) is overwritten. + enf h[8]' - h[8] = 0 when f_abp; + enf h[9]' - h[9] = 0 when f_abp; + enf h[10]' - h[10] = 0 when f_abp; + enf h[11]' - h[11] = 0 when f_abp; + + # FIXED: Changed from f_mp/f_mv/f_mu to f_mpa/f_mva/f_mua (correct absorption flags) + # + # Enforce that when absorbing the next node during Merkle path computation on cycle_row_7 + # (i.e. f_mpa + f_mva + f_mua = 1), the digest (h[0], ..., h[3]) is copied + # to rate0 (h'[0..3]) when b=0, or to rate1 (h'[4..7]) when b=1. + # + # TODO: uncomment when computed indices are supported + # enf match { + # !b & f_absorb_node: is_unchanged(h[j]) for j in 0..4, + # b & f_absorb_node: h[j + 4]' = h[j] for j in 0..4 + # } +} + +########################################################################################## +# HELPER FUNCTIONS +########################################################################################## + +########################################################################################## +# INSTRUCTION FLAGS - DETAILED DESCRIPTIONS +########################################################################################## +# +# The hasher chiplet uses selector columns s[0], s[1], s[2] to encode different operations: +# +# INITIALIZATION FLAGS (on rows which are multiples of 8 - cycle_row_0): +# • f_bp: (1,0,0) - Begin Permutation +# Initiates: single permutation, 2-to-1 hash, or linear hash computation +# • f_mp: (1,0,1) - Merkle Path verification +# Starts standard Merkle path verification computation +# • f_mv: (1,1,0) - Merkle path Verification for "old" node +# Begins verification for old leaf value during Merkle root update +# • f_mu: (1,1,1) - Merkle path verification for "new" node +# Starts verification for new leaf value during Merkle root update +# +# ABSORPTION FLAGS (on rows 1 less than multiple of 8 - cycle_row_7): +# • f_abp: (1,0,0) - Absorb elements for linear hash (continuing computation) +# Absorbs next set of elements into hasher state during linear hash +# • f_mpa: (1,0,1) - Merkle Path Absorb during standard verification +# Absorbs next Merkle path node during standard verification +# • f_mva: (1,1,0) - Merkle path absorb for "old" node verification +# Absorbs next node during "old" leaf verification (Merkle root update) +# • f_mua: (1,1,1) - Merkle path absorb for "new" node verification +# Absorbs next node during "new" leaf verification (Merkle root update) +# +# OUTPUT FLAGS (on rows 1 less than multiple of 8 - cycle_row_7): +# • f_hout: (0,0,0) - Hash Output +# Returns the result of the currently running hash computation +# • f_sout: (0,0,1) - State Output +# Returns the entire 12-element hasher state +# • f_out: Combined flag (f_hout | f_sout) - any output operation +# +########################################################################################## + +# f_bp: Begin Permutation flag (1,0,0) on cycle_row_0 +# Initiates single permutation, 2-to-1 hash, or linear hash computation. +fn get_f_bp(s: felt[3], row0: felt) -> felt { + return row0 & s[0] & binary_not(s[1]) & binary_not(s[2]); +} + +# f_mp: Merkle Path verification flag (1,0,1) on cycle_row_0 +# Initiates standard Merkle path verification computation. +fn get_f_mp(s: felt[3], row0: felt) -> felt { + return row0 & s[0] & binary_not(s[1]) & s[2]; +} + +# f_mv: Merkle path Verification for "old" node flag (1,1,0) on cycle_row_0 +# Begins verification for old leaf value during Merkle root update computation. +fn get_f_mv(s: felt[3], row0: felt) -> felt { + return row0 & s[0] & s[1] & binary_not(s[2]); +} + +# f_mu: Merkle path verification for "new" node flag (1,1,1) on cycle_row_0 +# Starts verification for new leaf value during Merkle root update computation. +fn get_f_mu(s: felt[3], row0: felt) -> felt { + return row0 & s[0] & s[1] & s[2]; +} + +# f_abp: Absorb elements for linear hash flag (1,0,0) on cycle_row_7 +# Absorbs next set of elements into hasher state during linear hash computation. +fn get_f_abp(s: felt[3], row7: felt) -> felt { + return row7 & s[0] & binary_not(s[1]) & binary_not(s[2]); +} + +# f_mpa: Merkle Path Absorb flag (1,0,1) on cycle_row_7 +# Absorbs next Merkle path node during standard verification computation. +fn get_f_mpa(s: felt[3], row7: felt) -> felt { + return row7 & s[0] & binary_not(s[1]) & s[2]; +} + +# f_mva: Merkle path absorb for "old" node flag (1,1,0) on cycle_row_7 +# Absorbs next node during "old" leaf verification (Merkle root update computation). +fn get_f_mva(s: felt[3], row7: felt) -> felt { + return row7 & s[0] & s[1] & binary_not(s[2]); +} + +# f_mua: Merkle path absorb for "new" node flag (1,1,1) on cycle_row_7 +# Absorbs next node during "new" leaf verification (Merkle root update computation). +fn get_f_mua(s: felt[3], row7: felt) -> felt { + return row7 & s[0] & s[1] & s[2]; +} + +# We can define two flags: +# 1. Flag f_hout = cycle_row_7 & binary_not(s[0]) & binary_not(s[1]) & binary_not(s[2]), +# which is set to 1 when selector flags are (0,0,0) on rows which are 1 less than a multiple +# of 8. This flag is for the instruction that returns the resulting digest of the currently +# running computation. +# 2. Flag f_sout = cycle_row_7 & binary_not(s[0]) & binary_not(s[1]) & s[2], which is set to 1 +# when selector flags are (0,0,1) on rows which are 1 less than a multiple of 8. This flag is +# for the instruction that returns the whole hasher state. +# +# Flag f_out is set to 1 when either f_hout = 1 or f_sout = 1 in the current row. +fn get_f_out(s: felt[3], row7: felt) -> felt { + return row7 & binary_not(s[0]) & binary_not(s[1]); +} + +# Flag f_out_next is set to 1 when either f_hout = 1 or f_sout = 1 in the next row. +fn get_f_out_next(s: felt[3], row6: felt, s0_next: felt, s1_next: felt) -> felt { + return row6 & binary_not(s0_next) & binary_not(s1_next); +} + +# f_hout: Hash Output flag (0,0,0) on cycle_row_7 +# Returns the 4-element hash result (h0-h3) +fn get_f_hout(s: felt[3], row7: felt) -> felt { + return row7 & binary_not(s[0]) & binary_not(s[1]) & binary_not(s[2]); +} + +# f_sout: State Output flag (0,0,1) on cycle_row_7 +# Returns the entire 12-element hasher state +fn get_f_sout(s: felt[3], row7: felt) -> felt { + return row7 & binary_not(s[0]) & binary_not(s[1]) & s[2]; +} + +########################################################################################## +# PERIODIC COLUMNS +########################################################################################## +# +# There are 3 periodic columns used to help select the instruction executed at a given row +# +periodic_columns { + cycle_row_0: [1, 0, 0, 0, 0, 0, 0, 0], + cycle_row_6: [0, 0, 0, 0, 0, 0, 1, 0], + cycle_row_7: [0, 0, 0, 0, 0, 0, 0, 1], +} diff --git a/constraints/kernel_rom.air b/constraints/kernel_rom.air new file mode 100644 index 000000000..b1275ee11 --- /dev/null +++ b/constraints/kernel_rom.air @@ -0,0 +1,114 @@ +########################################################################################## +# KERNEL ROM CHIPLET +########################################################################################## +# +# The Kernel ROM chiplet is responsible for tracking execution of kernel (system) calls. +# It maintains a record of all kernel procedure digests and ensures proper initialization +# of kernel procedures while preserving privacy about call frequency. +# +# The chiplet contains digest values for all kernel procedures and enforces contiguity +# constraints to ensure proper execution tracking. +# +# STATUS: Fully implemented (core constraints + bus responses complete) +# +# REFERENCES: +# - Kernel ROM Chiplet: https://0xmiden.github.io/miden-vm/design/chiplets/kernel_rom.html +########################################################################################## + +mod kernel_rom + +use utils::*; + +########################################################################################## +# KERNEL ROM CHIPLET TRANSITION CONSTRAINTS +########################################################################################## + +# Enforces the constraints on the kernel ROM chiplet given its columns. +# +# Max constraint degree: 3 +ev ker_rom_chiplet_constraints([s4, sfirst, r[4]]) { + #################################################################################### + # TRANSITION CONSTRAINTS + #################################################################################### + + enf kernel_rom_selector([sfirst]); + enf kernel_rom_digest_contiguity([s4, sfirst, r]); + + #################################################################################### + # BUS OPERATIONS - CHIPLETS COMMUNICATION + #################################################################################### + # The kernel ROM chiplet provides responses to kernel procedure requests via the + # chiplets bus. + # + # OPERATIONS: + # - KERNELPROCINIT (label = 48): Initialization from verifier (sfirst = 1) + # Responds to public input kernel digests on first row of digest block + # + # - KERNELPROCCALL (label = 16): Procedure call from decoder (sfirst = 0) + # Responds to SYSCALL operations on subsequent rows + # + # Response format: (operation_label, r0, r1, r2, r3) + # where r0-r3 form the 4-element kernel procedure digest. + #################################################################################### + + # Extract digest elements + let r0 = r[0]; + let r1 = r[1]; + let r2 = r[2]; + let r3 = r[3]; + + # Compute operation flags + let is_init = sfirst; # 1 when sfirst = 1 (initialization) + let is_call = binary_not(sfirst); # 1 when sfirst = 0 (procedure call) + + bus_6_chiplets_bus.remove(KERNELPROCINIT, r0, r1, r2, r3) when is_init; + bus_6_chiplets_bus.remove(KERNELPROCCALL, r0, r1, r2, r3) when is_call; +} + +# Enforces initialization constraints for the first row of kernel ROM chiplet execution. +# +# According to the official specification, the first row must have sfirst = 1 to ensure +# proper digest matching and initialization of kernel procedure tracking. +# +# Max constraint degree: 1 +ev kernel_rom_chiplet_constraints_first_row([s4, sfirst, r[4]]) { + # FIRST ROW INITIALIZATION CONSTRAINT: + # The first row of any kernel ROM chiplet execution must have sfirst' = 1 + # This ensures proper initialization of kernel procedure digest tracking. + # Without this, the chiplet could start in an invalid intermediate state. + enf sfirst' = 1; +} + +########################################################################################## +# HELPERS +########################################################################################## + +### Helper evaluators ############################################################################# + +# Enforces that the kernel ROM selector is valid. +# +# Max constraint degree: 2 +ev kernel_rom_selector([sfirst]) { + # Enforce that sfirst is binary (0 or 1). + # Constraint degree: 2 + enf is_binary([sfirst]); + + # First row initialization constraint + # This is part of the ACE chiplet constraints +} + +# Enforces digest contiguity constraints for the kernel ROM. +# +# When sfirst' = 0, consecutive rows must contain identical digest values to ensure +# proper tracking of kernel procedure executions. +# +# Max constraint degree: 3 +ev kernel_rom_digest_contiguity([s4, sfirst, r[4]]) { + # Enforce that when sfirst = 0 (not the start of a new digest block), + # the digest values in the current row must be identical to the next row. + # This ensures contiguous blocks of identical digest values. + # + # Note: This constraint is disabled when the current row is the last row of the kernel ROM chiplet + # which is indicated by s4' being set to 1 + enf is_unchanged([r]) for r in r when binary_and(binary_not(s4'), binary_not(sfirst')); +} diff --git a/constraints/memory.air b/constraints/memory.air new file mode 100644 index 000000000..24c557ae3 --- /dev/null +++ b/constraints/memory.air @@ -0,0 +1,300 @@ +########################################################################################## +# MEMORY CONSTRAINTS MODULE +########################################################################################## +# +# The Memory chiplet provides linear read-write random access memory for the Miden VM. +# Memory is element-addressable with addresses in range [0, 2^32), supporting both individual +# element access and optimized word-aligned batch operations (4 elements per word). +# +# MEMORY TABLE LAYOUT: +# ┌─────────┬──────────────────────────────────────────────────────────────────────────┐ +# │ Column │ Purpose │ +# ├─────────┼──────────────────────────────────────────────────────────────────────────┤ +# │ rw │ Read/write selector: 1=read, 0=write │ +# │ ew │ Element/word access selector: 0=element, 1=word │ +# │ ctx │ Context ID for execution context separation │ +# │ w_addr │ Word address (must be divisible by 4 for aligned access) │ +# │ idx0/1 │ Element index within word [0,3] - binary decomposition of low 2 bits │ +# │ clk │ Clock cycle when operation occurred │ +# │ v0-v3 │ Four field elements stored in memory word │ +# │ d0/d1 │ Delta tracking columns for monotonicity verification │ +# │ d_inv │ Inverse delta column for consecutive transitions │ +# │ f_scw │ Same context/word address flag for sequential access optimization │ +# └─────────┴──────────────────────────────────────────────────────────────────────────┘ +# +# STATUS: Fully implemented with chiplets bus integration +# +# NOTE: The spec currently omits explicit range checks to ensure addresses fit within the +# intended 32-bit space and that word accesses satisfy the divisibility-by-4 requirement +# (addr = 4 * w_addr + idx0 + 2 * idx1 with idx0/idx1 in {0,1}). These checks should be added +# in a follow-up pass. +# +# REFERENCES: +# - Memory Design: https://0xmiden.github.io/miden-vm/design/chiplets/memory.html +########################################################################################## + +mod memory + +use utils::*; + +########################################################################################## +# MEMORY CHIPLET TRANSITION CONSTRAINTS +########################################################################################## + +# Enforces proper memory initialization when entering memory chiplet +ev memory_chiplet_constraints_first_row([memory[15]]) { + let is_read = memory[0]; # Read(1)/Write(0) selector + let is_word_access = memory[1]; # Element(0)/Word(1) access selector + let ctx = memory[2]; # Context ID + let addr = memory[3]; # Memory address + let idx0 = memory[4]; # Element index bit 0 + let idx1 = memory[5]; # Element index bit 1 + let v0 = memory[7]; # Memory value 0 + let v1 = memory[8]; # Memory value 1 + let v2 = memory[9]; # Memory value 2 + let v3 = memory[10]; # Memory value 3 + + # Element selection flags: f[i] = 1 when element index (2*idx1 + idx0) equals i + let f0 = binary_not(idx1') * binary_not(idx0'); + let f1 = binary_not(idx1') * idx0'; + let f2 = idx1' * binary_not(idx0'); + let f3 = idx1' * idx0'; + + # c_i is set to 1 when `v'[i]` is not written to, and 0 otherwise. + # + # In other words, c_i is set to 1 when `v'[i]` needs to be constrained (to either 0 or `v[i]`). + # + # Note that `c_i` only uses values in the "next" row. This is because it must be used to + # constrain the first row of the memory chiplet, where that row sits in the "next" position of + # the frame, and the "current" row belongs to the previous chiplet (and hence the "current" row + # must not be accessed). + # + # As a result, `c_i` does not include the constraint of being in the memory chiplet, or in the + # same context and word - these must be enforced separately. + let f = [f0, f1, f2, f3]; + let c = [compute_c_i(f_i, is_read', is_word_access') for f_i in f]; + + # Enforce that when v'[i] is not written to, then v'[i] must be 0. + enf v0' = 0 when c[0]; + enf v1' = 0 when c[1]; + enf v2' = 0 when c[2]; + enf v3' = 0 when c[3]; +} + +# Enforces constraints that apply to every row in the memory chiplet +# These are basic validity constraints for selectors and indices +ev memory_chiplet_constraints_all_rows([memory[15]]) { + let is_read = memory[0]; # Read(1)/Write(0) selector + let is_word_access = memory[1]; # Element(0)/Word(1) access selector + let idx0 = memory[4]; # Element index bit 0 + let idx1 = memory[5]; # Element index bit 1 + + # Binary column constraints + enf enforce_binary_columns([is_read, is_word_access, idx0, idx1]); + # For word access, idx bits must be zero (only element access uses idx0/idx1). + enf is_word_access * idx0 = 0; + enf is_word_access * idx1 = 0; +} + +# Enforces memory state transition constraints for all rows except the final row +# Includes monotonicity, value consistency, proper read/write semantics, and bus interactions +ev memory_chiplet_constraints_all_rows_except_last([memory[15]]) { + let is_read = memory[0]; # Read(1)/Write(0) selector + let is_word_access = memory[1]; # Element(0)/Word(1) access selector + let ctx = memory[2]; # Context ID + let addr = memory[3]; # Memory address + let idx0 = memory[4]; # Element index bit 0 + let idx1 = memory[5]; # Element index bit 1 + let clk = memory[6]; # Clock cycle + let v0 = memory[7]; # Memory value 0 + let v1 = memory[8]; # Memory value 1 + let v2 = memory[9]; # Memory value 2 + let v3 = memory[10]; # Memory value 3 + let d0 = memory[11]; # Context delta + let d1 = memory[12]; # Address delta + let d_inv = memory[13]; # Delta inverse + let f_scw = memory[14]; # Same context/word flag + + # Delta inverse constraints + enf enforce_d_inv([ctx, addr, clk, d0, d1, d_inv]); + + # Context/address/clock delta constraints + enf enforce_delta([ctx, addr, clk, d0, d1, d_inv]); + + # Same context/word flag constraints + enf enforce_flag_same_context_and_word([ctx, addr, d_inv, f_scw]); + + # Same context/word/addr/clock access constraints + enf enforce_same_context_word_addr_and_clock([is_read, clk, f_scw, d_inv]); + + # Memory value constraints + enf enforce_values_consistency([is_read, is_word_access, idx0, idx1, v0, v1, v2, v3, f_scw]); + + #################################################################################### + # BUS OPERATIONS + #################################################################################### + # The memory chiplet provides responses to memory operation requests via the + # chiplets bus. + # + # OPERATIONS: + # - MEMREADWORD (label = 28): Read 4-element word from memory + # - MEMWRITEWORD (label = 20): Write 4-element word to memory + # - MEMREADELEMENT (label = 12): Read single element from memory + # - MEMWRITEELEMENT (label = 4): Write single element to memory + # + # All operations include context, address, and clock cycle + #################################################################################### + + # Compute operation flags + let is_word_read = is_read * is_word_access; + let is_word_write = binary_not(is_read) * is_word_access; + let is_element_read = is_read * binary_not(is_word_access); + let is_element_write = binary_not(is_read) * binary_not(is_word_access); + + # For element operations, compute which element is being accessed + let f0_bus = binary_not(idx1) * binary_not(idx0); + let f1_bus = binary_not(idx1) * idx0; + let f2_bus = idx1 * binary_not(idx0); + let f3_bus = idx1 * idx0; + let element_value = f0_bus * v0 + f1_bus * v1 + f2_bus * v2 + f3_bus * v3; + + # Compute element address: addr + idx0 + 2 * idx1. + # For word accesses, idx bits are 0, so this equals the word address. + let element_addr = addr + idx0 + 2 * idx1; + + # Remove responses from bus when operations occur + bus_6_chiplets_bus.remove(MEMREADWORD, ctx, element_addr, clk, v0, v1, v2, v3) when is_word_read; + bus_6_chiplets_bus.remove(MEMWRITEWORD, ctx, element_addr, clk, v0, v1, v2, v3) when is_word_write; + bus_6_chiplets_bus.remove(MEMREADELEMENT, ctx, element_addr, clk, element_value) when is_element_read; + bus_6_chiplets_bus.remove(MEMWRITEELEMENT, ctx, element_addr, clk, element_value) when is_element_write; +} + +########################################################################################## +# HELPER EVALUATORS +########################################################################################## + +# Constrains binary columns for selectors and indices +ev enforce_binary_columns([is_read, is_word_access, idx0, idx1]) { + # Read/write selector must be binary + enf is_binary([is_read]); + + # Element/word access selector must be binary + enf is_binary([is_word_access]); + + # Index bit 0 must be binary + enf is_binary([idx0]); + + # Index bit 1 must be binary + enf is_binary([idx1]); +} + +# Constrains the delta inverse column +ev enforce_d_inv([ctx, addr, clk, d0, d1, d_inv]) { + let ctx_delta = ctx' - ctx; + let addr_delta = addr' - addr; + let n0 = ctx_delta * d_inv'; + let n1 = addr_delta * d_inv'; + + # n0 is binary + enf binary_constraint(n0) = 0; + + # When context changes, n0 must be 1 + enf ctx_delta = 0 when binary_not(n0); + + # When n0 is 0 then n1 is binary + enf binary_constraint(n1) = 0 when binary_not(n0); + + # When n0 and n1 are both 0, then address must not change + enf addr_delta = 0 when binary_not(n0) * binary_not(n1); +} + +# Enforces monotonicity constraints for context, address, and clock transitions +ev enforce_delta([ctx, addr, clk, d0, d1, d_inv]) { + let ctx_delta = ctx' - ctx; + let addr_delta = addr' - addr; + let clk_delta = clk' - clk; + let delta_next = d1' * 2^16 + d0'; + let n0 = ctx_delta * d_inv'; + let n1 = addr_delta * d_inv'; + + enf n0 * ctx_delta + binary_not(n0) * (n1 * addr_delta + binary_not(n1) * clk_delta) = delta_next; +} + +# Enforces correct f_scw flag computation +ev enforce_flag_same_context_and_word([ctx, addr, d_inv, f_scw]) { + let ctx_delta = ctx' - ctx; + let addr_delta = addr' - addr; + let n0 = ctx_delta * d_inv'; + let n1 = addr_delta * d_inv'; + + enf f_scw' = binary_not(n0) * binary_not(n1); +} + +# Enforces that accesses to same context, word address, and clock must be reads +ev enforce_same_context_word_addr_and_clock([is_read, clk, f_scw, d_inv]) { + let clk_delta = clk' - clk; + let clk_no_change = binary_not(clk_delta * d_inv'); + + enf binary_not(is_read) * binary_not(is_read') = 0 when clk_no_change * f_scw'; +} + +# Enforces memory value consistency, and proper read/write semantics +ev enforce_values_consistency([is_read, is_word_access, idx0, idx1, v0, v1, v2, v3, f_scw]) { + # Element selection flags: f[i] = 1 when element index (2*idx1 + idx0) equals i + let f0 = binary_not(idx1') * binary_not(idx0'); + let f1 = binary_not(idx1') * idx0'; + let f2 = idx1' * binary_not(idx0'); + let f3 = idx1' * idx0'; + + # c_i is set to 1 when `v'[i]` is not written to, and 0 otherwise. + # + # In other words, c_i is set to 1 when `v'[i]` needs to be constrained (to either 0 or `v[i]`). + # + # Note that `c_i` only uses values in the "next" row. This is because it must be used to + # constrain the first row of the memory chiplet, where that row sits in the "next" position of + # the frame, and the "current" row belongs to the previous chiplet (and hence the "current" row + # must not be accessed). + # + # As a result, `c_i` does not include the constraint of being in the memory chiplet, or in the + # same context and word - these must be enforced separately. + let f = [f0, f1, f2, f3]; + let c = [compute_c_i(f_i, is_read', is_word_access') for f_i in f]; + + # Non-first row constraints: if v[i]' is not written to and, + # - (f_scw' = 1) then its value needs to be copied over from the previous row, + # - (f_scw' = 0) then its value needs to be set to 0. + enf f_scw' * (v0' - v0) + binary_not(f_scw') * v0' = 0 when c[0]; + enf f_scw' * (v1' - v1) + binary_not(f_scw') * v1' = 0 when c[1]; + enf f_scw' * (v2' - v2) + binary_not(f_scw') * v2' = 0 when c[2]; + enf f_scw' * (v3' - v3) + binary_not(f_scw') * v3' = 0 when c[3]; +} + +########################################################################################## +# HELPER FUNCTIONS +########################################################################################## + +# Memory chiplet active flag +fn flag_all_rows(s0: felt, s1: felt, s2: felt) -> felt { + return s0 * s1 * binary_not(s2); +} + +# Memory chiplet active flag for next row +fn flag_all_rows_next(s0: felt, s1: felt, s2: felt) -> felt { + return s0' * s1' * binary_not(s2'); +} + +# Memory chiplet active in current row and row is not the last one of the memory chiplet +fn flag_memory_active_not_last_row(s0: felt, s1: felt, s2: felt) -> felt { + return s0 * s1 * binary_not(s2'); +} + +# First row of memory chiplet (transitioning from bitwise to memory) +fn flag_next_row_first_row_memory(s0: felt, s1: felt, s2: felt) -> felt { + return (1 - s1) * flag_all_rows_next(s0, s1, s2); +} + +# Computes constraint flag: 1 if value needs to be constrained, 0 otherwise +fn compute_c_i(f_i: felt, is_read_next: felt, is_word_access_next: felt) -> felt { + let z_i = binary_not(is_word_access_next) * binary_not(f_i); + return is_read_next + binary_not(is_read_next) * z_i; +} diff --git a/constraints/miden-vm/bitwise.air b/constraints/miden-vm-old/bitwise.air similarity index 100% rename from constraints/miden-vm/bitwise.air rename to constraints/miden-vm-old/bitwise.air diff --git a/constraints/miden-vm/chiplets.air b/constraints/miden-vm-old/chiplets.air similarity index 100% rename from constraints/miden-vm/chiplets.air rename to constraints/miden-vm-old/chiplets.air diff --git a/constraints/miden-vm/decoder.air b/constraints/miden-vm-old/decoder.air similarity index 100% rename from constraints/miden-vm/decoder.air rename to constraints/miden-vm-old/decoder.air diff --git a/constraints/miden-vm/hash.air b/constraints/miden-vm-old/hash.air similarity index 100% rename from constraints/miden-vm/hash.air rename to constraints/miden-vm-old/hash.air diff --git a/constraints/miden-vm/memory.air b/constraints/miden-vm-old/memory.air similarity index 100% rename from constraints/miden-vm/memory.air rename to constraints/miden-vm-old/memory.air diff --git a/constraints/miden-vm/range_checker.air b/constraints/miden-vm-old/range_checker.air similarity index 100% rename from constraints/miden-vm/range_checker.air rename to constraints/miden-vm-old/range_checker.air diff --git a/constraints/miden_vm.air b/constraints/miden_vm.air new file mode 100644 index 000000000..3db02fd30 --- /dev/null +++ b/constraints/miden_vm.air @@ -0,0 +1,204 @@ +########################################################################################## +# MIDEN VM - ALGEBRAIC INTERMEDIATE REPRESENTATION (AIR) CONSTRAINTS +########################################################################################## +# +# The Miden Virtual Machine is a STARK-based zero-knowledge virtual machine designed for +# efficient execution and proving of arbitrary computations. This AIR specification defines +# the arithmetic constraints that govern the VM's execution. +# +# STATUS: Not fully implemented +# +# REFERENCES: +# - Miden VM implementation: https://0xmiden.github.io/miden-vm/ +# - Miden VM documentation : https://0xmiden.github.io/miden-vm/intro/main.html +########################################################################################## + +def MidenVM + +use chiplets::chiplets_constraints; +use decoder::decoder; +use bitwise::*; +use hasher::*; +use range_checker::*; +use stack::stack; +use system::*; +use utils::*; + +########################################################################################## +# EXECUTION TRACE LAYOUT +########################################################################################## +# +# The execution trace captures the state of the VM at each cycle. The main trace consists +# of 80 columns organized into logical segments. +# +########################################################################################## + +trace_columns { + main: [system[8], decoder[24], stack[19], range_checker[2], chiplets[20], padding[7]], +} + +########################################################################################## +# PUBLIC INPUTS +########################################################################################## +# +# Public inputs define the interface between the prover and verifier, establishing +# the computation's inputs and expected outputs that must be verified. +# +# INPUT STRUCTURE: +# ┌───────────────┬─────────┬───────────────────────────────────────────────────┐ +# │ Field │ Size │ Description │ +# ├───────────────┼─────────┼───────────────────────────────────────────────────┤ +# │ stack_inputs │ 16 │ Initial operand stack state (top 16 elements) │ +# │ stack_outputs │ 16 │ Final operand stack state (top 16 elements) │ +# │program_digest │ 4 │ MAST root hash identifying the executed program │ +# │kernel_digests │ [[5]] │ Hashes of kernel procedures (dynamic array) │ +# └───────────────┴─────────┴───────────────────────────────────────────────────┘ +# +########################################################################################## + +public_inputs { + stack_inputs: [16], # Initial operand stack state (16 field elements) + stack_outputs: [16], # Final operand stack state (16 field elements) + program_digest: [4], # MAST root hash (4 field elements) + kernel_digests: [[5]], # Kernel procedure hashes plus an op label +} + +########################################################################################## +# BUS ARCHITECTURE +########################################################################################## +# +# Buses enable efficient communication between VM components using cryptographic +# protocols like multiset checks and LogUp. They ensure data integrity and consistency +# across different execution units. +# +########################################################################################## + +buses { + # Decoder buses + multiset bus_0_decoder_p1, + multiset bus_1_decoder_p2, + multiset bus_2_decoder_p3, + + # Stack overflow table + multiset bus_3_stack_p1, + + # Range checker bus + logup bus_4_range_checker, + + # Chiplet buses + multiset bus_5_v_table, # Chiplets virtual table + multiset bus_6_chiplets_bus, # Main chiplets communication bus + + # Wiring bus + logup bus_7_wiring_bus, # ACE (Algebraic Circuit Elements) wiring +} + +########################################################################################## +# BOUNDARY CONSTRAINTS +########################################################################################## +# +# Boundary constraints establish the initial and final states of the VM execution. +# They ensure proper initialization and define the expected state at program completion. +# +########################################################################################## + +boundary_constraints { + #################################################################################### + # MAIN TRACE BOUNDARIES + #################################################################################### + + # System clock must start at 0 (VM begins execution at cycle 0) + enf system[0].first = 0; + + #################################################################################### + # STACK BOUNDARIES + #################################################################################### + + # Stack depth (b0) must be 16 at start and end + # This ensures the stack begins and ends with exactly 16 visible elements + enf stack[16].first = 16; # b0 = 16 (minimum stack depth) + enf stack[16].last = 16; # b0 = 16 (stack returns to minimum depth) + + # Overflow table address (b1) must be 0 at start and end + # This ensures no overflow elements exist at program boundaries + enf stack[17].first = 0; # b1 = 0 (no overflow at start) + enf stack[17].last = 0; # b1 = 0 (no overflow at end) + + # Decoder must start outside a basic block + enf decoder[16].first = 0; # sp = 0 + + #################################################################################### + # RANGE CHECKER BOUNDARIES + #################################################################################### + + # Range checker value column must span complete 16-bit range [0, 65535] + # The table uses gap handling (powers of 3) to skip unused values, but must + # start at 0 and end at the maximum 16-bit value to ensure complete coverage + enf range_checker[1].first = 0; # v = 0 (start of 16-bit range) + enf range_checker[1].last = 65535; # v = 65535 (end of 16-bit range, 2^16 - 1) + + #################################################################################### + # AUXILIARY COLUMN BOUNDARIES + #################################################################################### + + # Decoder buses + enf bus_0_decoder_p1.first = null; + enf bus_0_decoder_p1.last = null; + # Block hash table (p2) boundaries will be handled via aux_finals once buses are + # uniformized to start at 1/0, so we leave both ends unconstrained here. + enf bus_1_decoder_p2.first = unconstrained; + enf bus_1_decoder_p2.last = unconstrained; + enf bus_2_decoder_p3.first = null; + enf bus_2_decoder_p3.last = null; + + # Stack overflow table + enf bus_3_stack_p1.first = null; + enf bus_3_stack_p1.last = null; + + # Range checker bus + enf bus_4_range_checker.first = null; + enf bus_4_range_checker.last = null; + + # Chiplets virtual table + enf bus_5_v_table.first = unconstrained; + enf bus_5_v_table.last = unconstrained; + + # Chiplets communication bus + # Bus starts empty; kernel digests are folded in via kernel ROM responses. + # Final value is checked via aux_finals in the VM, so we leave last unconstrained here. + enf bus_6_chiplets_bus.first = null; + enf bus_6_chiplets_bus.last = unconstrained; + + # ACE wiring bus + # Ensures all nodes inserted are consumed exactly as many times as their multiplicity + enf bus_7_wiring_bus.first = null; + enf bus_7_wiring_bus.last = null; +} + +########################################################################################## +# INTEGRITY CONSTRAINTS +########################################################################################## +# +# Integrity constraints define the state transition rules that govern VM execution. +# These constraints ensure that each step of program execution is valid according +# to the Miden VM instruction set architecture. +# +########################################################################################## + +integrity_constraints { + # System state transitions (needs decoder columns for operation flags) + enf system_transition([system[0..8], decoder[0..24]]); + + # Decoder constraints - Program execution and operation decoding + # Requires: stack top (s0-s2), system (clk, ctx, fmp, fn_hash), overflow registers (b0, b1) + enf decoder([decoder, stack[0], stack[1], stack[2], system[0], system[2], system[1], stack[16], stack[17], system[4], system[5], system[6], system[7]]); + + # Stack constraints - Operand stack operations and overflow handling + enf stack([stack[0..19], decoder[0..24], system[0], system[1], system[2], system[4], system[5], system[6], system[7]]); + + # Chiplet constraints - Hash, bitwise, ACE, memory operations, and kernel ROM + enf chiplets_constraints([chiplets[0..20], system[0]]); + + # Range checker constraints - 16-bit range checks via LogUp protocol + enf range_checker_constraints([decoder[0..24], range_checker[0..2], chiplets[0..20]]); +} diff --git a/constraints/miden_vm_plonky3.rs b/constraints/miden_vm_plonky3.rs new file mode 100644 index 000000000..a414f68b9 --- /dev/null +++ b/constraints/miden_vm_plonky3.rs @@ -0,0 +1,276 @@ +use p3_field::{ExtensionField, Field, PrimeCharacteristicRing}; +use p3_matrix::Matrix; +use p3_matrix::dense::RowMajorMatrixView; +use p3_matrix::stack::VerticalPair; +use p3_miden_air::{BusType, MidenAir, MidenAirBuilder, RowMajorMatrix}; + +pub const MAIN_WIDTH: usize = 80; +pub const AUX_WIDTH: usize = 8; +pub const NUM_PERIODIC_VALUES: usize = 29; +pub const PERIOD: usize = 8; +pub const NUM_PUBLIC_VALUES: usize = 36; +pub const MAX_BETA_CHALLENGE_POWER: usize = 15; + +pub struct MidenVM; + +impl MidenAir for MidenVM +where F: Field, + EF: ExtensionField, +{ + fn width(&self) -> usize { + MAIN_WIDTH + } + + fn num_public_values(&self) -> usize { + NUM_PUBLIC_VALUES + } + + fn periodic_table(&self) -> Vec> { + vec![ + vec![F::from_u64(1), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0)], + vec![F::from_u64(1), F::from_u64(1), F::from_u64(1), F::from_u64(1), F::from_u64(1), F::from_u64(1), F::from_u64(1), F::from_u64(0)], + vec![F::from_u64(1), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0)], + vec![F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(1), F::from_u64(0)], + vec![F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(0), F::from_u64(1)], + vec![F::from_u64(5789762306288267264), F::from_u64(12987190162843097088), F::from_u64(18072785500942327808), F::from_u64(5674685213610122240), F::from_u64(4887609836208846848), F::from_u64(16308865189192448000), F::from_u64(7123075680859040768), F::from_u64(0)], + vec![F::from_u64(6522564764413702144), F::from_u64(653957632802705280), F::from_u64(6200974112677013504), F::from_u64(5759084860419474432), F::from_u64(3027115137917284352), F::from_u64(11977192855656443904), F::from_u64(1034205548717903104), F::from_u64(0)], + vec![F::from_u64(9602914297752487936), F::from_u64(8110510111539675136), F::from_u64(8884468225181997056), F::from_u64(17021852944633065472), F::from_u64(2955076958026921984), F::from_u64(13277683694236792832), F::from_u64(14345062289456084992), F::from_u64(0)], + vec![F::from_u64(16657542370200465408), F::from_u64(2872078294163232256), F::from_u64(13066900325715521536), F::from_u64(6252096473787587584), F::from_u64(7433723648458773504), F::from_u64(2600778905124452864), F::from_u64(17036731477169661952), F::from_u64(0)], + vec![F::from_u64(17809893479458207744), F::from_u64(4441654670647621120), F::from_u64(17682092219085883392), F::from_u64(13943282657648898048), F::from_u64(9595098600469471232), F::from_u64(12532242556065779712), F::from_u64(7717824418247931904), F::from_u64(0)], + vec![F::from_u64(107145243989736512), F::from_u64(4038207883745915904), F::from_u64(10599526828986757120), F::from_u64(1352748651966375424), F::from_u64(10528569829048483840), F::from_u64(14594890931430969344), F::from_u64(3019070937878604288), F::from_u64(0)], + vec![F::from_u64(6388978042437517312), F::from_u64(5613464648874829824), F::from_u64(975003873302957312), F::from_u64(17110913224029904896), F::from_u64(7864689113198940160), F::from_u64(7291784239689209856), F::from_u64(11403792746066868224), F::from_u64(0)], + vec![F::from_u64(15844067734406017024), F::from_u64(13222989726778339328), F::from_u64(8264241093196931072), F::from_u64(1003883795902368384), F::from_u64(17533723827845969920), F::from_u64(5514718540551361536), F::from_u64(10280580802233112576), F::from_u64(0)], + vec![F::from_u64(9975000513555218432), F::from_u64(3037761201230264320), F::from_u64(10065763900435474432), F::from_u64(4141870621881018368), F::from_u64(5781638039037711360), F::from_u64(10025733853830934528), F::from_u64(337153209462421248), F::from_u64(0)], + vec![F::from_u64(3344984123768313344), F::from_u64(16683759727265179648), F::from_u64(2181131744534710272), F::from_u64(8121410972417424384), F::from_u64(17024078752430718976), F::from_u64(7293794580341021696), F::from_u64(13333398568519923712), F::from_u64(0)], + vec![F::from_u64(9959189626657347584), F::from_u64(8337364536491240448), F::from_u64(6317303992309419008), F::from_u64(14300518605864919040), F::from_u64(109659393484013504), F::from_u64(6728552937464861696), F::from_u64(3596153696935337472), F::from_u64(0)], + vec![F::from_u64(12960773468763564032), F::from_u64(3227397518293416448), F::from_u64(1401440938888741632), F::from_u64(13712227150607669248), F::from_u64(7158933660534805504), F::from_u64(6332385040983343104), F::from_u64(8104208463525993472), F::from_u64(0)], + vec![F::from_u64(6077062762357203968), F::from_u64(6202948458916100096), F::from_u64(8023374565629191168), F::from_u64(18389244934624493568), F::from_u64(6982293561042363392), F::from_u64(3736792340494631424), F::from_u64(17130398059294019584), F::from_u64(0)], + vec![F::from_u64(15277620170502010880), F::from_u64(17690140365333231616), F::from_u64(15013690343205953536), F::from_u64(16731736864863924224), F::from_u64(14065426295947720704), F::from_u64(577852220195055360), F::from_u64(519782857322262016), F::from_u64(0)], + vec![F::from_u64(10063319113072093184), F::from_u64(17731621626449383424), F::from_u64(9045979173463557120), F::from_u64(14512769585918244864), F::from_u64(6844229992533661696), F::from_u64(4571485474751953408), F::from_u64(3611348709641382912), F::from_u64(0)], + vec![F::from_u64(14200078843431360512), F::from_u64(2897136237748376064), F::from_u64(12934431667190679552), F::from_u64(10973956031244050432), F::from_u64(7446486531695178752), F::from_u64(17200392109565784064), F::from_u64(18256379591337758720), F::from_u64(0)], + vec![F::from_u64(5358738125714196480), F::from_u64(3595001575307484672), F::from_u64(4485500052507913216), F::from_u64(4440209734760478208), F::from_u64(16451845770444974080), F::from_u64(6689998335515780096), F::from_u64(9625384390925084672), F::from_u64(0)], + vec![F::from_u64(14233283787297595392), F::from_u64(373995945117666496), F::from_u64(12489737547229155328), F::from_u64(17208448209698889728), F::from_u64(7139138592091307008), F::from_u64(13886063479078012928), F::from_u64(1664893052631119104), F::from_u64(0)], + vec![F::from_u64(13792579614346651648), F::from_u64(1235734395091296000), F::from_u64(9500452585969031168), F::from_u64(8739495587021565952), F::from_u64(9012006439959783424), F::from_u64(14358505101923203072), F::from_u64(7629576092524553216), F::from_u64(0)], + vec![F::from_u64(11614812331536766976), F::from_u64(14172757457833930752), F::from_u64(2054001340201038848), F::from_u64(17000774922218162176), F::from_u64(14619614108529063936), F::from_u64(7744142531772273664), F::from_u64(3485239601103661568), F::from_u64(0)], + vec![F::from_u64(14871063686742261760), F::from_u64(707573103686350208), F::from_u64(12420704059284934656), F::from_u64(13533282547195531264), F::from_u64(1394813199588124416), F::from_u64(16135070735728404480), F::from_u64(9755891797164034048), F::from_u64(0)], + vec![F::from_u64(10148237148793042944), F::from_u64(15453217512188186624), F::from_u64(355990932618543744), F::from_u64(525402848358706240), F::from_u64(4635111139507788800), F::from_u64(12290902521256030208), F::from_u64(15218148195153268736), F::from_u64(0)], + vec![F::from_u64(4457428952329675776), F::from_u64(219777875004506016), F::from_u64(9071225051243524096), F::from_u64(16987541523062161408), F::from_u64(16217473952264204288), F::from_u64(12059913662657710080), F::from_u64(16460604813734957056), F::from_u64(0)], + vec![F::from_u64(15590786458219171840), F::from_u64(17876696346199468032), F::from_u64(12766199826003447808), F::from_u64(5466806524462796800), F::from_u64(10782018226466330624), F::from_u64(16456018495793752064), F::from_u64(9643968136937730048), F::from_u64(0)], + ] + } + + fn num_randomness(&self) -> usize { + 1 + MAX_BETA_CHALLENGE_POWER + } + + fn aux_width(&self) -> usize { + AUX_WIDTH + } + + fn bus_types(&self) -> &[BusType] { + &[ + BusType::Multiset, + BusType::Multiset, + BusType::Multiset, + BusType::Multiset, + BusType::Logup, + BusType::Multiset, + BusType::Multiset, + BusType::Logup, + ] + } + + fn eval(&self, builder: &mut AB) + where AB: MidenAirBuilder, + { + let public_values: [_; NUM_PUBLIC_VALUES] = builder.public_values().try_into().expect("Wrong number of public values"); + let periodic_values: [_; NUM_PERIODIC_VALUES] = builder.periodic_evals().try_into().expect("Wrong number of periodic values"); + // Note: for now, we do not have any preprocessed values + // let preprocessed = builder.preprocessed(); + let main = builder.main(); + let (main_current, main_next) = ( + main.row_slice(0).unwrap(), + main.row_slice(1).unwrap(), + ); + let (&alpha, beta_challenges) = builder.permutation_randomness().split_first().expect("Wrong number of randomness"); + let beta_challenges: [_; MAX_BETA_CHALLENGE_POWER] = beta_challenges.try_into().expect("Wrong number of randomness"); + let aux_bus_boundary_values: [_; AUX_WIDTH] = builder.aux_bus_boundary_values().try_into().expect("Wrong number of aux bus boundary values"); + let aux = builder.permutation(); + let (aux_current, aux_next) = ( + aux.row_slice(0).unwrap(), + aux.row_slice(1).unwrap(), + ); + + // Main boundary constraints + builder.when_first_row().assert_zero(main_current[0].clone().into()); + builder.when_first_row().assert_zero(main_current[48].clone().into() - AB::Expr::from_u64(16)); + builder.when_last_row().assert_zero(main_current[48].clone().into() - AB::Expr::from_u64(16)); + builder.when_first_row().assert_zero(main_current[49].clone().into()); + builder.when_last_row().assert_zero(main_current[49].clone().into()); + builder.when_first_row().assert_zero(main_current[24].clone().into()); + builder.when_first_row().assert_zero(main_current[52].clone().into()); + builder.when_last_row().assert_zero(main_current[52].clone().into() - AB::Expr::from_u64(65535)); + + // Main integrity/transition constraints + builder.when_transition().assert_zero(main_next[0].clone().into() - (main_current[0].clone().into() + AB::Expr::ONE)); + builder.when_transition().assert_zero((main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[2].clone().into() - (main_current[0].clone().into() + AB::Expr::ONE))); + builder.when_transition().assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_next[2].clone().into()); + builder.when_transition().assert_zero((AB::Expr::ONE - (main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()))) * (main_next[2].clone().into() - main_current[2].clone().into())); + builder.when_transition().assert_zero((main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[4].clone().into() - main_current[16].clone().into())); + builder.when_transition().assert_zero((main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[5].clone().into() - main_current[17].clone().into())); + builder.when_transition().assert_zero((main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[6].clone().into() - main_current[18].clone().into())); + builder.when_transition().assert_zero((main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[7].clone().into() - main_current[19].clone().into())); + builder.when_transition().assert_zero((AB::Expr::ONE - (main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()))) * (main_next[4].clone().into() - main_current[4].clone().into())); + builder.when_transition().assert_zero((AB::Expr::ONE - (main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()))) * (main_next[5].clone().into() - main_current[5].clone().into())); + builder.when_transition().assert_zero((AB::Expr::ONE - (main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()))) * (main_next[6].clone().into() - main_current[6].clone().into())); + builder.when_transition().assert_zero((AB::Expr::ONE - (main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()))) * (main_next[7].clone().into() - main_current[7].clone().into())); + builder.assert_zero((main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_current[32].clone().into() * main_current[32].clone().into() - main_current[32].clone().into())); + builder.assert_zero(main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * main_current[20].clone().into()); + builder.assert_zero(main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * main_current[21].clone().into()); + builder.assert_zero(main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * main_current[22].clone().into()); + builder.assert_zero(main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * main_current[23].clone().into()); + builder.assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (main_current[32].clone().into() - AB::Expr::ONE)); + builder.assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (main_current[20].clone().into() - AB::Expr::ONE)); + builder.when_transition().assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (main_next[8].clone().into() - (main_current[8].clone().into() + AB::Expr::from_u64(8)))); + builder.assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[21].clone().into() * main_current[32].clone().into()); + builder.when_transition().assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_next[31].clone().into() * main_next[13].clone().into() * (AB::Expr::ONE - main_next[12].clone().into()) * main_next[11].clone().into() * (main_next[16].clone().into() - main_current[16].clone().into())); + builder.when_transition().assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_next[31].clone().into() * main_next[13].clone().into() * (AB::Expr::ONE - main_next[12].clone().into()) * main_next[11].clone().into() * (main_next[17].clone().into() - main_current[17].clone().into())); + builder.when_transition().assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_next[31].clone().into() * main_next[13].clone().into() * (AB::Expr::ONE - main_next[12].clone().into()) * main_next[11].clone().into() * (main_next[18].clone().into() - main_current[18].clone().into())); + builder.when_transition().assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_next[31].clone().into() * main_next[13].clone().into() * (AB::Expr::ONE - main_next[12].clone().into()) * main_next[11].clone().into() * (main_next[19].clone().into() - main_current[19].clone().into())); + builder.when_transition().assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_next[31].clone().into() * main_next[13].clone().into() * (AB::Expr::ONE - main_next[12].clone().into()) * main_next[11].clone().into() * (main_next[20].clone().into() - main_current[20].clone().into())); + builder.when_transition().assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_next[31].clone().into() * main_next[13].clone().into() * main_next[12].clone().into() * main_next[11].clone().into())); + builder.assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[8].clone().into()); + builder.assert_zero(main_current[9].clone().into() * main_current[9].clone().into() - main_current[9].clone().into()); + builder.assert_zero(main_current[10].clone().into() * main_current[10].clone().into() - main_current[10].clone().into()); + builder.assert_zero(main_current[11].clone().into() * main_current[11].clone().into() - main_current[11].clone().into()); + builder.assert_zero(main_current[12].clone().into() * main_current[12].clone().into() - main_current[12].clone().into()); + builder.assert_zero(main_current[13].clone().into() * main_current[13].clone().into() - main_current[13].clone().into()); + builder.assert_zero(main_current[14].clone().into() * main_current[14].clone().into() - main_current[14].clone().into()); + builder.assert_zero(main_current[15].clone().into() * main_current[15].clone().into() - main_current[15].clone().into()); + builder.assert_zero(main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() + main_current[31].clone().into() * main_current[13].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) - (AB::Expr::ONE - main_current[24].clone().into())); + builder.assert_zero(main_current[24].clone().into() * main_current[24].clone().into() - main_current[24].clone().into()); + builder.when_transition().assert_zero((main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into())) * (main_next[24].clone().into() - AB::Expr::ONE)); + builder.when_transition().assert_zero(main_current[24].clone().into() * (main_next[8].clone().into() - main_current[8].clone().into())); + builder.when_transition().assert_zero(main_current[24].clone().into() * (main_current[25].clone().into() - main_next[25].clone().into()) * (main_current[25].clone().into() - main_next[25].clone().into() - AB::Expr::ONE)); + builder.when_transition().assert_zero(main_current[24].clone().into() * (main_current[25].clone().into() - main_next[25].clone().into()) * (AB::Expr::ONE - main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * main_current[16].clone().into()); + builder.when_transition().assert_zero((main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_current[25].clone().into() - main_next[25].clone().into() - AB::Expr::ONE)); + builder.when_transition().assert_zero((main_current[25].clone().into() - main_next[25].clone().into()) * (main_next[31].clone().into() * main_next[13].clone().into() * (AB::Expr::ONE - main_next[12].clone().into()) * (AB::Expr::ONE - main_next[11].clone().into()) + main_next[31].clone().into() * main_next[13].clone().into() * main_next[12].clone().into() * (AB::Expr::ONE - main_next[11].clone().into()))); + builder.assert_zero(main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[25].clone().into()); + builder.when_transition().assert_zero((main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + main_current[24].clone().into() * main_next[24].clone().into() * (AB::Expr::ONE - (main_current[25].clone().into() - main_next[25].clone().into()))) * (main_current[16].clone().into() - (main_next[16].clone().into() * AB::Expr::from_u64(128) + main_next[9].clone().into() + main_next[10].clone().into().double() + AB::Expr::from_u64(4) * main_next[11].clone().into() + AB::Expr::from_u64(8) * main_next[12].clone().into() + AB::Expr::from_u64(16) * main_next[13].clone().into() + AB::Expr::from_u64(32) * main_next[14].clone().into() + AB::Expr::from_u64(64) * main_next[15].clone().into()))); + builder.when_transition().assert_zero(main_current[24].clone().into() * (main_next[31].clone().into() * main_next[13].clone().into() * (AB::Expr::ONE - main_next[12].clone().into()) * (AB::Expr::ONE - main_next[11].clone().into()) + main_next[31].clone().into() * main_next[13].clone().into() * main_next[12].clone().into() * (AB::Expr::ONE - main_next[11].clone().into())) * main_current[16].clone().into()); + builder.when_transition().assert_zero((main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into())) * main_next[26].clone().into()); + builder.when_transition().assert_zero(main_current[24].clone().into() * (main_current[25].clone().into() - main_next[25].clone().into() - main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * main_next[26].clone().into()); + builder.when_transition().assert_zero(main_current[24].clone().into() * main_next[24].clone().into() * (AB::Expr::ONE - (main_current[25].clone().into() - main_next[25].clone().into() - main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into())) * (main_next[26].clone().into() - main_current[26].clone().into() - AB::Expr::ONE)); + builder.assert_zero(main_current[26].clone().into() * (main_current[26].clone().into() - AB::Expr::ONE) * (main_current[26].clone().into() - AB::Expr::from_u64(2)) * (main_current[26].clone().into() - AB::Expr::from_u64(3)) * (main_current[26].clone().into() - AB::Expr::from_u64(4)) * (main_current[26].clone().into() - AB::Expr::from_u64(5)) * (main_current[26].clone().into() - AB::Expr::from_u64(6)) * (main_current[26].clone().into() - AB::Expr::from_u64(7)) * (main_current[26].clone().into() - AB::Expr::from_u64(8))); + builder.assert_zero(main_current[27].clone().into() * main_current[27].clone().into() - main_current[27].clone().into()); + builder.assert_zero(main_current[28].clone().into() * main_current[28].clone().into() - main_current[28].clone().into()); + builder.assert_zero(main_current[29].clone().into() * main_current[29].clone().into() - main_current[29].clone().into()); + builder.assert_zero(main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) - ((AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * (AB::Expr::ONE - main_current[28].clone().into()) * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * (AB::Expr::ONE - main_current[29].clone().into()) + main_current[27].clone().into())); + builder.assert_zero((AB::Expr::ONE - (main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()))) * (main_current[27].clone().into() + main_current[28].clone().into() + main_current[29].clone().into())); + builder.assert_zero(((AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * (AB::Expr::ONE - main_current[28].clone().into()) * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * (AB::Expr::ONE - main_current[29].clone().into())) * main_current[20].clone().into()); + builder.assert_zero(((AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * (AB::Expr::ONE - main_current[28].clone().into()) * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * (AB::Expr::ONE - main_current[29].clone().into())) * main_current[21].clone().into()); + builder.assert_zero(((AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * (AB::Expr::ONE - main_current[28].clone().into()) * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * (AB::Expr::ONE - main_current[29].clone().into())) * main_current[22].clone().into()); + builder.assert_zero(((AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * (AB::Expr::ONE - main_current[28].clone().into()) * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * (AB::Expr::ONE - main_current[29].clone().into())) * main_current[23].clone().into()); + builder.assert_zero(((AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * (AB::Expr::ONE - main_current[28].clone().into()) * main_current[29].clone().into()) * main_current[18].clone().into()); + builder.assert_zero(((AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * main_current[29].clone().into() + (AB::Expr::ONE - main_current[27].clone().into()) * (AB::Expr::ONE - main_current[28].clone().into()) * main_current[29].clone().into()) * main_current[19].clone().into()); + builder.assert_zero((AB::Expr::ONE - main_current[27].clone().into()) * main_current[28].clone().into() * main_current[29].clone().into() * main_current[17].clone().into()); + builder.assert_zero(main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[9].clone().into()); + builder.assert_zero(main_current[30].clone().into() - main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into()); + builder.assert_zero(main_current[31].clone().into() - main_current[15].clone().into() * main_current[14].clone().into()); + builder.assert_zero(main_current[31].clone().into() * main_current[9].clone().into()); + builder.assert_zero(main_current[31].clone().into() * main_current[10].clone().into()); + builder.assert_zero((main_current[48].clone().into() - AB::Expr::from_u64(16)) * (AB::Expr::ONE - (main_current[48].clone().into() - AB::Expr::from_u64(16)) * main_current[50].clone().into())); + builder.when_transition().assert_zero(main_next[48].clone().into() - main_current[48].clone().into() - ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[21].clone().into()) * (main_current[48].clone().into() - AB::Expr::from_u64(16)) * main_current[50].clone().into()); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[49].clone().into() - main_current[0].clone().into())); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[21].clone().into()) * (AB::Expr::ONE - (main_current[48].clone().into() - AB::Expr::from_u64(16)) * main_current[50].clone().into()) * main_next[47].clone().into()); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[45].clone().into() - main_current[45].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[40].clone().into() - main_current[41].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[41].clone().into() - main_current[40].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[32].clone().into() - main_current[44].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[36].clone().into() - main_current[44].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * main_next[36].clone().into() * (main_next[36].clone().into() - AB::Expr::ONE) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (main_next[45].clone().into() - (main_current[45].clone().into() + AB::Expr::from_u64(8)))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[41].clone().into() - main_current[41].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[41].clone().into() - main_current[42].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[42].clone().into() - main_current[41].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[33].clone().into() - main_current[41].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * main_next[37].clone().into() * (main_next[37].clone().into() - AB::Expr::ONE)); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[42].clone().into() - main_current[42].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[42].clone().into() - main_current[43].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[43].clone().into() - main_current[42].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[34].clone().into() - main_current[42].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * main_next[38].clone().into() * (main_next[38].clone().into() - AB::Expr::ONE)); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[43].clone().into() - main_current[43].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[43].clone().into() - main_current[44].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[44].clone().into() - main_current[43].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[35].clone().into() - main_current[43].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * main_next[39].clone().into() * (main_next[39].clone().into() - AB::Expr::ONE)); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into())) * (main_next[46].clone().into() - main_current[46].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[44].clone().into() - main_current[45].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[45].clone().into() - main_current[44].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[33].clone().into() - main_current[45].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[37].clone().into() - main_current[45].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[39].clone().into() + main_next[38].clone().into() + main_next[37].clone().into() + main_next[36].clone().into() - AB::Expr::ONE) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[20].clone().into() - (main_current[46].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(7) * main_current[46].clone().into() * main_current[17].clone().into() * main_current[17].clone().into() + AB::Expr::from_u64(14) * main_current[47].clone().into() * main_current[16].clone().into() * main_current[17].clone().into() + main_current[32].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(7) * main_current[33].clone().into() * main_current[17].clone().into() + main_current[34].clone().into())) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_current[20].clone().into() - (main_current[46].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(7) * main_current[46].clone().into() * main_current[17].clone().into() * main_current[17].clone().into() + AB::Expr::from_u64(14) * main_current[47].clone().into() * main_current[16].clone().into() * main_current[17].clone().into() + main_current[32].clone().into() * main_current[16].clone().into() + main_current[33].clone().into()))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into())) * (main_next[47].clone().into() - main_current[47].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[45].clone().into() - main_current[46].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[46].clone().into() - main_current[45].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[34].clone().into() - main_current[46].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[38].clone().into() - main_current[46].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[41].clone().into() - (main_next[39].clone().into() + main_next[38].clone().into().double() + AB::Expr::from_u64(3) * main_next[37].clone().into() + AB::Expr::from_u64(4) * main_next[36].clone().into() - AB::Expr::ONE)) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[21].clone().into() - (main_current[47].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(7) * main_current[47].clone().into() * main_current[17].clone().into() * main_current[17].clone().into() + main_current[46].clone().into().double() * main_current[16].clone().into() * main_current[17].clone().into() + main_current[33].clone().into() * main_current[16].clone().into() + main_current[32].clone().into() * main_current[17].clone().into() + main_current[35].clone().into())) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_current[21].clone().into() - (main_current[47].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(7) * main_current[47].clone().into() * main_current[17].clone().into() * main_current[17].clone().into() + main_current[46].clone().into().double() * main_current[16].clone().into() * main_current[17].clone().into() + main_current[32].clone().into() * main_current[17].clone().into()))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[44].clone().into() - main_current[44].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[46].clone().into() - main_current[47].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[47].clone().into() - main_current[46].clone().into()) + (main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into())) * (main_next[44].clone().into() - (main_current[44].clone().into() + AB::Expr::from_u64(8))) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[35].clone().into() - main_current[47].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[39].clone().into() - main_current[47].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[41].clone().into() - (main_next[39].clone().into() + main_next[38].clone().into() * AB::Expr::from_u64(18446462594437873665) + main_next[37].clone().into() * AB::Expr::from_u64(18446744069414584320) + main_next[36].clone().into() * AB::Expr::from_u64(281474976710656)))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[40].clone().into() - main_current[40].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[39].clone().into() - main_current[40].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[40].clone().into() - main_current[39].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[41].clone().into() - main_current[33].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[20].clone().into() * main_next[41].clone().into() - main_current[42].clone().into() * AB::Expr::from_u64(7)) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[32].clone().into() - (main_current[32].clone().into() * main_current[37].clone().into() + (AB::Expr::ONE - main_current[32].clone().into()) * main_current[33].clone().into()))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[39].clone().into() - main_current[39].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[38].clone().into() - main_current[39].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[39].clone().into() - main_current[38].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[33].clone().into() - main_current[37].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[44].clone().into() - main_current[36].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[20].clone().into() * main_current[21].clone().into() - AB::Expr::ONE) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[33].clone().into() - (main_current[32].clone().into() * main_current[38].clone().into() + (AB::Expr::ONE - main_current[32].clone().into()) * main_current[34].clone().into()))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[38].clone().into() - main_current[38].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[37].clone().into() - main_current[38].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[38].clone().into() - main_current[37].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[34].clone().into() - main_current[38].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[45].clone().into() - main_current[37].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[16].clone().into() - main_current[46].clone().into() * main_current[21].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[34].clone().into() - (main_current[32].clone().into() * main_current[39].clone().into() + (AB::Expr::ONE - main_current[32].clone().into()) * main_current[35].clone().into()))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[37].clone().into() - main_current[37].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[36].clone().into() - main_current[37].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[37].clone().into() - main_current[36].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[35].clone().into() - main_current[39].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[46].clone().into() - main_current[38].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[17].clone().into() - main_current[45].clone().into() * main_current[21].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[35].clone().into() - (main_current[32].clone().into() * main_current[40].clone().into() + (AB::Expr::ONE - main_current[32].clone().into()) * main_current[36].clone().into()))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[31].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[36].clone().into() - main_current[36].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[36].clone().into() - main_current[35].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[35].clone().into() - main_current[36].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[37].clone().into() - main_current[33].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[47].clone().into() - main_current[39].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[18].clone().into() - (main_current[16].clone().into() * main_current[16].clone().into() - main_current[17].clone().into().double() * main_current[17].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[36].clone().into() - (main_current[32].clone().into() * main_current[33].clone().into() + (AB::Expr::ONE - main_current[32].clone().into()) * main_current[37].clone().into()))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[33].clone().into() - main_current[32].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[34].clone().into() - main_current[35].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[33].clone().into() - main_current[33].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[42].clone().into() - main_current[34].clone().into()) + (main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[33].clone().into() - (main_current[17].clone().into() * AB::Expr::from_u64(65536) + main_current[16].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[32].clone().into() - main_current[4].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[34].clone().into() - main_current[32].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() * main_next[32].clone().into() * (main_next[32].clone().into() - AB::Expr::ONE) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[38].clone().into() - main_current[34].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[44].clone().into() - main_current[32].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[19].clone().into() - (main_current[16].clone().into().double() * main_current[17].clone().into() - main_current[17].clone().into() * main_current[17].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[37].clone().into() - (main_current[32].clone().into() * main_current[34].clone().into() + (AB::Expr::ONE - main_current[32].clone().into()) * main_current[38].clone().into())) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[32].clone().into() + main_current[33].clone().into() - (main_current[18].clone().into() * AB::Expr::from_u64(4294967296) + main_current[17].clone().into() * AB::Expr::from_u64(65536) + main_current[16].clone().into())) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[32].clone().into() * main_current[33].clone().into() - (main_current[19].clone().into() * AB::Expr::from_u64(281474976710656) + main_current[18].clone().into() * AB::Expr::from_u64(4294967296) + main_current[17].clone().into() * AB::Expr::from_u64(65536) + main_current[16].clone().into())) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[33].clone().into() - (main_current[32].clone().into() * main_next[33].clone().into() + main_next[32].clone().into())) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[32].clone().into() - (main_current[19].clone().into() * AB::Expr::from_u64(281474976710656) + main_current[18].clone().into() * AB::Expr::from_u64(4294967296) + main_current[17].clone().into() * AB::Expr::from_u64(65536) + main_current[16].clone().into()))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[34].clone().into() - main_current[33].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[33].clone().into() - main_current[34].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[34].clone().into() - main_current[34].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[43].clone().into() - main_current[35].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[33].clone().into() - main_current[5].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[33].clone().into() - main_current[33].clone().into() * main_current[33].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[39].clone().into() - main_current[35].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[34].clone().into() - (main_current[32].clone().into() * main_current[34].clone().into() + AB::Expr::from_u64(7) * main_current[33].clone().into() * main_current[35].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[45].clone().into() - main_current[33].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[33].clone().into().double() - (main_current[39].clone().into() + main_current[35].clone().into() + (main_current[39].clone().into() - main_current[35].clone().into()) * main_current[16].clone().into() - (main_current[38].clone().into() - main_current[34].clone().into()).double() * main_current[17].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[32].clone().into() - (main_current[32].clone().into() * main_current[34].clone().into() + (AB::Expr::ONE - main_current[32].clone().into()) * main_current[33].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[38].clone().into() - (main_current[32].clone().into() * main_current[35].clone().into() + (AB::Expr::ONE - main_current[32].clone().into()) * main_current[39].clone().into())) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[32].clone().into() + main_current[33].clone().into() + main_current[34].clone().into() - (main_current[18].clone().into() * AB::Expr::from_u64(4294967296) + main_current[17].clone().into() * AB::Expr::from_u64(65536) + main_current[16].clone().into())) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[32].clone().into() * main_current[33].clone().into() + main_current[34].clone().into() - (main_current[19].clone().into() * AB::Expr::from_u64(281474976710656) + main_current[18].clone().into() * AB::Expr::from_u64(4294967296) + main_current[17].clone().into() * AB::Expr::from_u64(65536) + main_current[16].clone().into()))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[35].clone().into() - main_current[34].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[35].clone().into() - main_current[35].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[40].clone().into() - main_current[32].clone().into()) + (main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[48].clone().into() - AB::Expr::from_u64(16)) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[36].clone().into() - main_current[32].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[32].clone().into() - main_current[32].clone().into() * main_current[33].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[34].clone().into() - main_current[6].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[35].clone().into() - main_current[32].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() * (main_current[16].clone().into() - ((main_current[33].clone().into() - AB::Expr::ONE) * main_next[32].clone().into() + AB::Expr::ONE)) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[37].clone().into() - main_current[32].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[38].clone().into() - main_current[32].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[39].clone().into() - main_current[32].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[35].clone().into() - ((main_current[32].clone().into() + main_current[33].clone().into()) * (main_current[34].clone().into() + main_current[35].clone().into()) - main_current[32].clone().into() * main_current[34].clone().into() - main_current[33].clone().into() * main_current[35].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[46].clone().into() - main_current[34].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[32].clone().into() - AB::Expr::ONE) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_current[32].clone().into() - main_current[33].clone().into()) * main_next[32].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[32].clone().into() - (main_current[32].clone().into() + main_current[33].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_current[33].clone().into() * main_current[33].clone().into() - main_current[33].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[32].clone().into().double() - (main_current[38].clone().into() + main_current[34].clone().into() + (main_current[39].clone().into() - main_current[35].clone().into() + main_current[38].clone().into() - main_current[34].clone().into()) * (main_current[16].clone().into() + main_current[17].clone().into()) - (main_current[39].clone().into() - main_current[35].clone().into()) * main_current[16].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[33].clone().into() - (main_current[32].clone().into() * main_current[33].clone().into() + (AB::Expr::ONE - main_current[32].clone().into()) * main_current[34].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[39].clone().into() - (main_current[32].clone().into() * main_current[36].clone().into() + (AB::Expr::ONE - main_current[32].clone().into()) * main_current[40].clone().into()))); + builder.when_transition().assert_zero(((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[32].clone().into() - main_current[33].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[32].clone().into() - main_current[32].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_current[32].clone().into() * main_current[32].clone().into() - main_current[32].clone().into()) + (main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[32].clone().into() - (main_current[17].clone().into() * AB::Expr::from_u64(65536) + main_current[16].clone().into())) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into()) * (main_next[32].clone().into() - main_current[36].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[32].clone().into() - main_current[40].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[32].clone().into() - main_current[34].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[32].clone().into() - main_current[35].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[32].clone().into() - main_current[37].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into()) * (main_next[32].clone().into() - main_current[38].clone().into()) + ((AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[32].clone().into() - main_current[39].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * main_next[32].clone().into() * main_current[32].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[32].clone().into() + main_current[32].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[32].clone().into() * main_current[32].clone().into() - AB::Expr::ONE) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[32].clone().into() - (main_current[32].clone().into() + AB::Expr::ONE)) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[35].clone().into() - main_current[7].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[34].clone().into() - main_current[34].clone().into() * main_current[16].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[47].clone().into() - main_current[35].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[32].clone().into() - (AB::Expr::ONE - (main_current[32].clone().into() - main_current[33].clone().into()) * main_current[16].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[35].clone().into().double() - (main_current[37].clone().into() + main_current[33].clone().into() + (main_current[37].clone().into() - main_current[33].clone().into()) * main_current[16].clone().into() * AB::Expr::from_u64(18446462594437873665) - (main_current[36].clone().into() - main_current[32].clone().into()).double() * main_current[17].clone().into() * AB::Expr::from_u64(18446462594437873665))) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * main_next[32].clone().into() + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[32].clone().into() - main_current[41].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[32].clone().into() - main_current[43].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[32].clone().into() - main_current[45].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[32].clone().into() - main_current[47].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[32].clone().into() - main_current[48].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[32].clone().into() - main_current[0].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[33].clone().into() - main_next[33].clone().into() - (main_current[17].clone().into() * AB::Expr::from_u64(65536) + main_current[16].clone().into())) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[32].clone().into() - (main_current[19].clone().into() * AB::Expr::from_u64(65536) + main_current[18].clone().into()))); + builder.when_transition().assert_zero((main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[33].clone().into() - (main_current[19].clone().into() * AB::Expr::from_u64(65536) + main_current[18].clone().into())) + (main_current[31].clone().into() * main_current[13].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[31].clone().into() * main_current[13].clone().into() * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * main_next[49].clone().into() + (main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into())) * (main_next[33].clone().into() - main_current[18].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[32].clone().into() - (AB::Expr::ONE - main_current[32].clone().into() * main_current[16].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[32].clone().into() - (AB::Expr::ONE - main_current[32].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * main_current[9].clone().into() * (main_next[35].clone().into() - (main_current[35].clone().into().double() + main_next[32].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[32].clone().into() - (main_current[32].clone().into() + main_current[33].clone().into() - main_current[32].clone().into() * main_current[33].clone().into())) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[34].clone().into().double() - (main_current[36].clone().into() + main_current[32].clone().into() + (main_current[37].clone().into() - main_current[33].clone().into() + main_current[36].clone().into() - main_current[32].clone().into()) * (main_current[16].clone().into() * AB::Expr::from_u64(18446462594437873665) + main_current[17].clone().into() * AB::Expr::from_u64(18446462594437873665)) - (main_current[37].clone().into() - main_current[33].clone().into()) * main_current[16].clone().into() * AB::Expr::from_u64(18446462594437873665))) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[33].clone().into() - main_current[32].clone().into() - (main_next[33].clone().into() + main_next[32].clone().into() * AB::Expr::from_u64(4294967296))) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_current[32].clone().into() - main_next[32].clone().into() - AB::Expr::ONE - (main_current[19].clone().into() * AB::Expr::from_u64(65536) + main_current[18].clone().into())) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[46].clone().into() - (main_current[20].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(7) * main_current[20].clone().into() * main_current[17].clone().into() * main_current[17].clone().into() + AB::Expr::from_u64(14) * main_current[21].clone().into() * main_current[16].clone().into() * main_current[17].clone().into() + main_current[36].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(7) * main_current[37].clone().into() * main_current[17].clone().into() + main_current[38].clone().into())) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_current[18].clone().into() - (main_current[20].clone().into() * (main_current[16].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(21) * main_current[16].clone().into() * main_current[17].clone().into() * main_current[17].clone().into()) + main_current[21].clone().into() * (AB::Expr::from_u64(21) * main_current[16].clone().into() * main_current[16].clone().into() * main_current[17].clone().into() + AB::Expr::from_u64(49) * main_current[17].clone().into() * main_current[17].clone().into() * main_current[17].clone().into()) + main_current[34].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(7) * main_current[34].clone().into() * main_current[17].clone().into() * main_current[17].clone().into() + main_current[35].clone().into() * main_current[16].clone().into() + main_current[36].clone().into()))); + builder.when_transition().assert_zero((main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * (AB::Expr::ONE - main_current[12].clone().into()) * main_current[11].clone().into() * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) + main_current[15].clone().into() * (AB::Expr::ONE - main_current[14].clone().into()) * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * main_current[11].clone().into() * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into())) * (AB::Expr::ONE - main_current[20].clone().into() * (AB::Expr::from_u64(4294967295) - (main_current[19].clone().into() * AB::Expr::from_u64(65536) + main_current[18].clone().into()))) * (main_current[17].clone().into() * AB::Expr::from_u64(65536) + main_current[16].clone().into()) + (AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[46].clone().into().double() - (main_next[33].clone().into() + main_next[35].clone().into() + (main_next[33].clone().into() - main_next[35].clone().into()) * main_current[18].clone().into() - (main_next[32].clone().into() - main_next[34].clone().into()).double() * main_current[19].clone().into())) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * main_current[10].clone().into() * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[47].clone().into() - (main_current[21].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(7) * main_current[21].clone().into() * main_current[17].clone().into() * main_current[17].clone().into() + main_current[20].clone().into().double() * main_current[16].clone().into() * main_current[17].clone().into() + main_current[37].clone().into() * main_current[16].clone().into() + main_current[36].clone().into() * main_current[17].clone().into() + main_current[39].clone().into())) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_current[19].clone().into() - (main_current[20].clone().into() * (AB::Expr::from_u64(3) * main_current[16].clone().into() * main_current[16].clone().into() * main_current[17].clone().into() + AB::Expr::from_u64(7) * main_current[17].clone().into() * main_current[17].clone().into() * main_current[17].clone().into()) + main_current[21].clone().into() * (main_current[16].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(21) * main_current[16].clone().into() * main_current[17].clone().into() * main_current[17].clone().into()) + main_current[34].clone().into().double() * main_current[16].clone().into() * main_current[17].clone().into() + main_current[35].clone().into() * main_current[17].clone().into()))); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[45].clone().into().double() - (main_next[32].clone().into() + main_next[34].clone().into() + (main_next[33].clone().into() - main_next[35].clone().into() + main_next[32].clone().into() - main_next[34].clone().into()) * (main_current[18].clone().into() + main_current[19].clone().into()) - (main_next[33].clone().into() - main_next[35].clone().into()) * main_current[18].clone().into())) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[46].clone().into() - (main_current[18].clone().into() * (main_current[16].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(21) * main_current[16].clone().into() * main_current[17].clone().into() * main_current[17].clone().into()) + main_current[19].clone().into() * (AB::Expr::from_u64(21) * main_current[16].clone().into() * main_current[16].clone().into() * main_current[17].clone().into() + AB::Expr::from_u64(49) * main_current[17].clone().into() * main_current[17].clone().into() * main_current[17].clone().into()) + main_current[37].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(7) * main_current[37].clone().into() * main_current[17].clone().into() * main_current[17].clone().into() + main_current[38].clone().into() * main_current[16].clone().into() + main_current[39].clone().into()))); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * ((main_current[39].clone().into() - main_current[44].clone().into()) * main_next[39].clone().into() + (main_current[37].clone().into() - main_current[44].clone().into()) * main_next[38].clone().into() + (main_current[35].clone().into() - main_current[44].clone().into()) * main_next[37].clone().into() + (main_current[33].clone().into() - main_current[44].clone().into()) * main_next[36].clone().into()) + main_current[30].clone().into() * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * main_current[9].clone().into() * (main_next[47].clone().into() - (main_current[18].clone().into() * (AB::Expr::from_u64(3) * main_current[16].clone().into() * main_current[16].clone().into() * main_current[17].clone().into() + AB::Expr::from_u64(7) * main_current[17].clone().into() * main_current[17].clone().into() * main_current[17].clone().into()) + main_current[19].clone().into() * (main_current[16].clone().into() * main_current[16].clone().into() * main_current[16].clone().into() + AB::Expr::from_u64(21) * main_current[16].clone().into() * main_current[17].clone().into() * main_current[17].clone().into()) + main_current[37].clone().into().double() * main_current[16].clone().into() * main_current[17].clone().into() + main_current[38].clone().into() * main_current[17].clone().into()))); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * ((main_current[38].clone().into() - main_current[43].clone().into()) * main_next[39].clone().into() + (main_current[36].clone().into() - main_current[43].clone().into()) * main_next[38].clone().into() + (main_current[34].clone().into() - main_current[43].clone().into()) * main_next[37].clone().into() + (main_current[32].clone().into() - main_current[43].clone().into()) * main_next[36].clone().into())); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[40].clone().into() - main_current[42].clone().into() * main_current[42].clone().into())); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[43].clone().into() - main_next[40].clone().into() * main_next[40].clone().into())); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[42].clone().into() - (main_current[47].clone().into() + AB::Expr::from_u64(8)))); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[15].clone().into()) * main_current[14].clone().into() * (AB::Expr::ONE - main_current[13].clone().into()) * main_current[12].clone().into() * (AB::Expr::ONE - main_current[11].clone().into()) * (AB::Expr::ONE - main_current[10].clone().into()) * (AB::Expr::ONE - main_current[9].clone().into()) * (main_next[44].clone().into() - main_current[40].clone().into())); + builder.assert_zero(main_current[53].clone().into() * main_current[53].clone().into() - main_current[53].clone().into()); + builder.assert_zero(main_current[53].clone().into() * (main_current[54].clone().into() * main_current[54].clone().into() - main_current[54].clone().into())); + builder.assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (main_current[55].clone().into() * main_current[55].clone().into() - main_current[55].clone().into())); + builder.assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * (main_current[56].clone().into() * main_current[56].clone().into() - main_current[56].clone().into())); + builder.assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * main_current[56].clone().into() * (main_current[57].clone().into() * main_current[57].clone().into() - main_current[57].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * (main_next[53].clone().into() - main_current[53].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (main_next[54].clone().into() - main_current[54].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * (main_next[55].clone().into() - main_current[55].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * main_current[56].clone().into() * (main_next[56].clone().into() - main_current[56].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * main_current[56].clone().into() * main_current[57].clone().into() * (main_next[57].clone().into() - main_current[57].clone().into())); + builder.assert_zero((main_current[53].clone().into() * (AB::Expr::ONE - main_current[54].clone().into()) + main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * (AB::Expr::ONE - main_current[56].clone().into()) + main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * main_current[56].clone().into() * (AB::Expr::ONE - main_current[57].clone().into())) * (main_current[58].clone().into() * main_current[58].clone().into() - main_current[58].clone().into()) + (AB::Expr::ONE - main_current[53].clone().into()) * (main_current[53].clone().into() * main_current[53].clone().into() - main_current[53].clone().into()) + main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_current[55].clone().into()) * (main_current[56].clone().into() * main_current[56].clone().into() - main_current[56].clone().into())); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[53].clone().into() + main_current[53].clone().into() * (AB::Expr::ONE - main_current[54].clone().into())) * (main_current[55].clone().into() * main_current[55].clone().into() - main_current[55].clone().into()) + (main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_current[55].clone().into()) + main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * (AB::Expr::ONE - main_current[56].clone().into())) * (main_current[57].clone().into() * main_current[57].clone().into() - main_current[57].clone().into()) + main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * main_current[56].clone().into() * (AB::Expr::ONE - main_current[57].clone().into()) * (AB::Expr::ONE - main_next[57].clone().into()) * (AB::Expr::ONE - main_next[58].clone().into()) * (main_next[59].clone().into() - main_current[59].clone().into())); + builder.when_transition().assert_zero((main_current[53].clone().into() * (AB::Expr::ONE - main_current[54].clone().into()) + main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_current[55].clone().into())) * (main_current[60].clone().into() * main_current[60].clone().into() - main_current[60].clone().into()) + (AB::Expr::ONE - main_current[53].clone().into()) * (main_current[54].clone().into() * main_current[54].clone().into() - main_current[54].clone().into()) + main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * (AB::Expr::ONE - main_current[56].clone().into()) * main_next[56].clone().into() * main_current[57].clone().into() + main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * main_current[56].clone().into() * (AB::Expr::ONE - main_current[57].clone().into()) * (AB::Expr::ONE - main_next[57].clone().into()) * (AB::Expr::ONE - main_next[58].clone().into()) * (main_next[60].clone().into() - main_current[60].clone().into())); + builder.when_transition().assert_zero_ext((AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into()))) * (AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from(main_current[61].clone().into()) - AB::ExprEF::from(main_current[61].clone().into())) + (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into()))) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[3].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[54].clone().into()))) * (AB::ExprEF::from(main_next[54].clone().into()) - AB::ExprEF::from(main_current[54].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from(main_next[57].clone().into()) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * AB::ExprEF::from(main_current[56].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[57].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[58].clone().into())) * (AB::ExprEF::from(main_next[61].clone().into()) - AB::ExprEF::from(main_current[61].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into()))) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[3].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[54].clone().into()))) * (AB::ExprEF::from(main_next[55].clone().into()) - AB::ExprEF::from(main_current[55].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(periodic_values[1].clone().into()) * (AB::ExprEF::from(main_next[55].clone().into()) - AB::ExprEF::from(main_current[55].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from(main_current[60].clone().into()) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from(main_current[58].clone().into()) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * AB::ExprEF::from(main_current[56].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[57].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[58].clone().into())) * (AB::ExprEF::from(main_next[62].clone().into()) - AB::ExprEF::from(main_current[62].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_next[53].clone().into()) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from(main_current[59].clone().into()) - AB::ExprEF::from(main_current[59].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from(main_current[61].clone().into()) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into())) * AB::ExprEF::from(main_current[58].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[58].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(main_current[54].clone().into()) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from(main_current[62].clone().into()) - AB::ExprEF::from(main_current[62].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * ((AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_current[57].clone().into()) + AB::ExprEF::from(main_next[56].clone().into()) - (AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from(main_next[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) + AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) + AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) + AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) + AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) + AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into())) * ((AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()) - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from(main_current[63].clone().into()) - AB::ExprEF::from(main_current[63].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into())) * ((AB::ExprEF::ONE - AB::ExprEF::from(main_next[58].clone().into())) * (AB::ExprEF::from(main_next[69].clone().into()) - AB::ExprEF::from(main_next[63].clone().into())) + AB::ExprEF::from(main_next[63].clone().into()) - AB::ExprEF::from(main_current[69].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[68].clone().into()) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from(main_current[64].clone().into()) - AB::ExprEF::from(main_current[64].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[57].clone().into())) * (AB::ExprEF::from(main_next[59].clone().into()) - AB::ExprEF::from(main_current[59].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - (AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) + AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) + AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) + AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) + AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) + AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) + AB::ExprEF::from(periodic_values[4].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())))) * (AB::ExprEF::from(main_next[68].clone().into()) - AB::ExprEF::from(main_current[68].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from(main_current[65].clone().into()) - AB::ExprEF::from(main_current[65].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[57].clone().into())) * (AB::ExprEF::from(main_next[61].clone().into()) - AB::ExprEF::from(main_current[61].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[17].clone().into()) - AB::ExprEF::from(main_next[56].clone().into()) * AB::ExprEF::from(main_next[56].clone().into()) * AB::ExprEF::from(main_next[56].clone().into()) * AB::ExprEF::from(main_next[56].clone().into()) * AB::ExprEF::from(main_next[56].clone().into()) * AB::ExprEF::from(main_next[56].clone().into()) * AB::ExprEF::from(main_next[56].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(periodic_values[0].clone().into()) * (AB::ExprEF::from(main_current[56].clone().into()) - (AB::ExprEF::from(main_current[58].clone().into()) + AB::ExprEF::from(main_current[59].clone().into()).double() + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[60].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8))) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[57].clone().into())) * (AB::ExprEF::from(main_next[60].clone().into()) - (AB::ExprEF::from(main_current[60].clone().into()) + AB::ExprEF::from_u64(4) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into())) + AB::ExprEF::from(main_current[58].clone().into())))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[18].clone().into()) - AB::ExprEF::from(main_next[57].clone().into()) * AB::ExprEF::from(main_next[57].clone().into()) * AB::ExprEF::from(main_next[57].clone().into()) * AB::ExprEF::from(main_next[57].clone().into()) * AB::ExprEF::from(main_next[57].clone().into()) * AB::ExprEF::from(main_next[57].clone().into()) * AB::ExprEF::from(main_next[57].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(periodic_values[0].clone().into()) * (AB::ExprEF::from(main_current[57].clone().into()) - (AB::ExprEF::from(main_current[62].clone().into()) + AB::ExprEF::from(main_current[63].clone().into()).double() + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[64].clone().into()) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8))) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[57].clone().into())) * (AB::ExprEF::from(main_current[63].clone().into()) - (AB::ExprEF::from(main_next[63].clone().into()) + (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into())).double() + AB::ExprEF::from(main_current[58].clone().into())))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[21].clone().into()) - AB::ExprEF::from(main_next[58].clone().into()) * AB::ExprEF::from(main_next[58].clone().into()) * AB::ExprEF::from(main_next[58].clone().into()) * AB::ExprEF::from(main_next[58].clone().into()) * AB::ExprEF::from(main_next[58].clone().into()) * AB::ExprEF::from(main_next[58].clone().into()) * AB::ExprEF::from(main_next[58].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(periodic_values[1].clone().into()) * (AB::ExprEF::from(main_next[56].clone().into()) - (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(16) + AB::ExprEF::from(main_current[58].clone().into()) + AB::ExprEF::from(main_current[59].clone().into()).double() + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[60].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8))) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into())) * (AB::ExprEF::from(main_current[66].clone().into()) - (AB::ExprEF::from(main_current[63].clone().into()) - AB::ExprEF::ONE))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[22].clone().into()) - AB::ExprEF::from(main_next[59].clone().into()) * AB::ExprEF::from(main_next[59].clone().into()) * AB::ExprEF::from(main_next[59].clone().into()) * AB::ExprEF::from(main_next[59].clone().into()) * AB::ExprEF::from(main_next[59].clone().into()) * AB::ExprEF::from(main_next[59].clone().into()) * AB::ExprEF::from(main_next[59].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(periodic_values[1].clone().into()) * (AB::ExprEF::from(main_next[57].clone().into()) - (AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(16) + AB::ExprEF::from(main_current[62].clone().into()) + AB::ExprEF::from(main_current[63].clone().into()).double() + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[64].clone().into()) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8))) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[58].clone().into()) * (AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from(main_current[62].clone().into()) - AB::ExprEF::from(main_current[62].clone().into())) * (AB::ExprEF::from(main_current[62].clone().into()) + AB::ExprEF::ONE)); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[23].clone().into()) - AB::ExprEF::from(main_next[60].clone().into()) * AB::ExprEF::from(main_next[60].clone().into()) * AB::ExprEF::from(main_next[60].clone().into()) * AB::ExprEF::from(main_next[60].clone().into()) * AB::ExprEF::from(main_next[60].clone().into()) * AB::ExprEF::from(main_next[60].clone().into()) * AB::ExprEF::from(main_next[60].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(periodic_values[0].clone().into()) * AB::ExprEF::from(main_current[66].clone().into()) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[58].clone().into()) * (AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from(main_current[62].clone().into()) * (AB::ExprEF::from(main_current[67].clone().into()) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from(main_current[70].clone().into()) - (AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from(main_current[70].clone().into()) + AB::ExprEF::from_u64(7) * AB::ExprEF::from(main_current[68].clone().into()) * AB::ExprEF::from(main_current[71].clone().into()))) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from(main_current[70].clone().into()) + AB::ExprEF::from_u64(7) * AB::ExprEF::from(main_current[68].clone().into()) * AB::ExprEF::from(main_current[71].clone().into()) - AB::ExprEF::from(main_current[64].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[24].clone().into()) - AB::ExprEF::from(main_next[61].clone().into()) * AB::ExprEF::from(main_next[61].clone().into()) * AB::ExprEF::from(main_next[61].clone().into()) * AB::ExprEF::from(main_next[61].clone().into()) * AB::ExprEF::from(main_next[61].clone().into()) * AB::ExprEF::from(main_next[61].clone().into()) * AB::ExprEF::from(main_next[61].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(periodic_values[1].clone().into()) * (AB::ExprEF::from(main_next[66].clone().into()) - AB::ExprEF::from(main_current[67].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[58].clone().into()) * (AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from(main_current[62].clone().into()) * (AB::ExprEF::from(main_current[68].clone().into()) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from(main_current[71].clone().into()) - ((AB::ExprEF::from(main_current[70].clone().into()) + AB::ExprEF::from(main_current[71].clone().into())) * (AB::ExprEF::from(main_current[67].clone().into()) + AB::ExprEF::from(main_current[68].clone().into())) - AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from(main_current[70].clone().into()) - AB::ExprEF::from(main_current[68].clone().into()) * AB::ExprEF::from(main_current[71].clone().into()))) + (AB::ExprEF::from(main_current[70].clone().into()) + AB::ExprEF::from(main_current[71].clone().into())) * (AB::ExprEF::from(main_current[67].clone().into()) + AB::ExprEF::from(main_current[68].clone().into())) - AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from(main_current[70].clone().into()) - AB::ExprEF::from(main_current[68].clone().into()) * AB::ExprEF::from(main_current[71].clone().into()) - AB::ExprEF::from(main_current[65].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[25].clone().into()) - AB::ExprEF::from(main_next[62].clone().into()) * AB::ExprEF::from(main_next[62].clone().into()) * AB::ExprEF::from(main_next[62].clone().into()) * AB::ExprEF::from(main_next[62].clone().into()) * AB::ExprEF::from(main_next[62].clone().into()) * AB::ExprEF::from(main_next[62].clone().into()) * AB::ExprEF::from(main_next[62].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::from(main_current[67].clone().into()) - (AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(16) + AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::from(main_current[58].clone().into()) + AB::ExprEF::from(main_current[62].clone().into()) - (AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from(main_current[62].clone().into()) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from(main_current[62].clone().into())) + (AB::ExprEF::from(main_current[59].clone().into()) + AB::ExprEF::from(main_current[63].clone().into()) - (AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from(main_current[63].clone().into()) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from(main_current[63].clone().into()))).double() + AB::ExprEF::from_u64(4) * (AB::ExprEF::from(main_current[60].clone().into()) + AB::ExprEF::from(main_current[64].clone().into()) - (AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from(main_current[64].clone().into()) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from(main_current[64].clone().into()))) + AB::ExprEF::from_u64(8) * (AB::ExprEF::from(main_current[61].clone().into()) + AB::ExprEF::from(main_current[65].clone().into()) - (AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from(main_current[65].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from(main_current[65].clone().into()))) - (AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from(main_current[62].clone().into()) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from(main_current[63].clone().into()) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from(main_current[63].clone().into()) + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from(main_current[64].clone().into()) + AB::ExprEF::from_u64(8) * AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from(main_current[65].clone().into()))) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from(main_current[62].clone().into()) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from(main_current[63].clone().into()) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from(main_current[63].clone().into()) + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from(main_current[64].clone().into()) + AB::ExprEF::from_u64(8) * AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from(main_current[65].clone().into()))) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * ((AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_next[57].clone().into()) + AB::ExprEF::from(main_next[56].clone().into()) - (AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_next[57].clone().into()) * AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_current[64].clone().into())); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[26].clone().into()) - AB::ExprEF::from(main_next[63].clone().into()) * AB::ExprEF::from(main_next[63].clone().into()) * AB::ExprEF::from(main_next[63].clone().into()) * AB::ExprEF::from(main_next[63].clone().into()) * AB::ExprEF::from(main_next[63].clone().into()) * AB::ExprEF::from(main_next[63].clone().into()) * AB::ExprEF::from(main_next[63].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * ((AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_next[57].clone().into()) + AB::ExprEF::from(main_next[56].clone().into()) - (AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_next[57].clone().into()) * AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_current[65].clone().into())); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[27].clone().into()) - AB::ExprEF::from(main_next[64].clone().into()) * AB::ExprEF::from(main_next[64].clone().into()) * AB::ExprEF::from(main_next[64].clone().into()) * AB::ExprEF::from(main_next[64].clone().into()) * AB::ExprEF::from(main_next[64].clone().into()) * AB::ExprEF::from(main_next[64].clone().into()) * AB::ExprEF::from(main_next[64].clone().into())) + AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * ((AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_next[57].clone().into()) + AB::ExprEF::from(main_next[56].clone().into()) - (AB::ExprEF::ONE - AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_next[57].clone().into()) * AB::ExprEF::from(main_next[56].clone().into())) * AB::ExprEF::from(main_current[63].clone().into())); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[28].clone().into()) - AB::ExprEF::from(main_next[65].clone().into()) * AB::ExprEF::from(main_next[65].clone().into()) * AB::ExprEF::from(main_next[65].clone().into()) * AB::ExprEF::from(main_next[65].clone().into()) * AB::ExprEF::from(main_next[65].clone().into()) * AB::ExprEF::from(main_next[65].clone().into()) * AB::ExprEF::from(main_next[65].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[19].clone().into()) - AB::ExprEF::from(main_next[66].clone().into()) * AB::ExprEF::from(main_next[66].clone().into()) * AB::ExprEF::from(main_next[66].clone().into()) * AB::ExprEF::from(main_next[66].clone().into()) * AB::ExprEF::from(main_next[66].clone().into()) * AB::ExprEF::from(main_next[66].clone().into()) * AB::ExprEF::from(main_next[66].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[4].clone().into())) * ((AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[5].clone().into())) * AB::ExprEF::from_u64(23) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(periodic_values[6].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(periodic_values[9].clone().into())) * AB::ExprEF::from_u64(26) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(periodic_values[10].clone().into())) * AB::ExprEF::from_u64(13) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[11].clone().into())) * AB::ExprEF::from_u64(10) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(periodic_values[12].clone().into())) * AB::ExprEF::from_u64(9) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(periodic_values[13].clone().into())) * AB::ExprEF::from_u64(7) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(periodic_values[14].clone().into())) * AB::ExprEF::from_u64(6) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(periodic_values[15].clone().into())) * AB::ExprEF::from_u64(22) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(periodic_values[16].clone().into())) * AB::ExprEF::from_u64(21) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(periodic_values[7].clone().into())) * AB::ExprEF::from_u64(8) + (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * (AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from_u64(23) + AB::ExprEF::from(main_current[57].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[58].clone().into()) * AB::ExprEF::from_u64(26) + AB::ExprEF::from(main_current[59].clone().into()) * AB::ExprEF::from_u64(13) + AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from_u64(10) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from_u64(9) + AB::ExprEF::from(main_current[62].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(main_current[63].clone().into()) * AB::ExprEF::from_u64(6) + AB::ExprEF::from(main_current[64].clone().into()) * AB::ExprEF::from_u64(22) + AB::ExprEF::from(main_current[65].clone().into()) * AB::ExprEF::from_u64(21) + AB::ExprEF::from(main_current[66].clone().into()) * AB::ExprEF::from_u64(8) + AB::ExprEF::from(main_current[67].clone().into()) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[8].clone().into())) * AB::ExprEF::from_u64(7) + AB::ExprEF::from(periodic_values[20].clone().into()) - AB::ExprEF::from(main_next[67].clone().into()) * AB::ExprEF::from(main_next[67].clone().into()) * AB::ExprEF::from(main_next[67].clone().into()) * AB::ExprEF::from(main_next[67].clone().into()) * AB::ExprEF::from(main_next[67].clone().into()) * AB::ExprEF::from(main_next[67].clone().into()) * AB::ExprEF::from(main_next[67].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::from(main_next[64].clone().into()) - AB::ExprEF::from(main_current[64].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::from(main_next[65].clone().into()) - AB::ExprEF::from(main_current[65].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::from(main_next[66].clone().into()) - AB::ExprEF::from(main_current[66].clone().into()))); + builder.when_transition().assert_zero_ext((AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::from(main_next[67].clone().into()) - AB::ExprEF::from(main_current[67].clone().into()))); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[54].clone().into()) * main_next[53].clone().into() * main_next[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (main_next[56].clone().into() + (AB::Expr::ONE - main_next[56].clone().into()) * (AB::Expr::ONE - main_next[57].clone().into()) * (AB::Expr::ONE - (AB::Expr::ONE - main_next[61].clone().into()) * (AB::Expr::ONE - main_next[60].clone().into()))) * main_next[63].clone().into()); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[54].clone().into()) * main_next[53].clone().into() * main_next[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (main_next[56].clone().into() + (AB::Expr::ONE - main_next[56].clone().into()) * (AB::Expr::ONE - main_next[57].clone().into()) * (AB::Expr::ONE - (AB::Expr::ONE - main_next[61].clone().into()) * main_next[60].clone().into())) * main_next[64].clone().into()); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[54].clone().into()) * main_next[53].clone().into() * main_next[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (main_next[56].clone().into() + (AB::Expr::ONE - main_next[56].clone().into()) * (AB::Expr::ONE - main_next[57].clone().into()) * (AB::Expr::ONE - main_next[61].clone().into() * (AB::Expr::ONE - main_next[60].clone().into()))) * main_next[65].clone().into()); + builder.when_transition().assert_zero((AB::Expr::ONE - main_current[54].clone().into()) * main_next[53].clone().into() * main_next[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (main_next[56].clone().into() + (AB::Expr::ONE - main_next[56].clone().into()) * (AB::Expr::ONE - main_next[57].clone().into()) * (AB::Expr::ONE - main_next[61].clone().into() * main_next[60].clone().into())) * main_next[66].clone().into()); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * ((main_next[58].clone().into() - main_current[58].clone().into()) * main_next[69].clone().into() * (main_next[58].clone().into() - main_current[58].clone().into()) * main_next[69].clone().into() - (main_next[58].clone().into() - main_current[58].clone().into()) * main_next[69].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (AB::Expr::ONE - (main_next[58].clone().into() - main_current[58].clone().into()) * main_next[69].clone().into()) * (main_next[58].clone().into() - main_current[58].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (AB::Expr::ONE - (main_next[58].clone().into() - main_current[58].clone().into()) * main_next[69].clone().into()) * ((main_next[59].clone().into() - main_current[59].clone().into()) * main_next[69].clone().into() * (main_next[59].clone().into() - main_current[59].clone().into()) * main_next[69].clone().into() - (main_next[59].clone().into() - main_current[59].clone().into()) * main_next[69].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (AB::Expr::ONE - (main_next[58].clone().into() - main_current[58].clone().into()) * main_next[69].clone().into()) * (AB::Expr::ONE - (main_next[59].clone().into() - main_current[59].clone().into()) * main_next[69].clone().into()) * (main_next[59].clone().into() - main_current[59].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * ((main_next[58].clone().into() - main_current[58].clone().into()) * main_next[69].clone().into() * (main_next[58].clone().into() - main_current[58].clone().into()) + (AB::Expr::ONE - (main_next[58].clone().into() - main_current[58].clone().into()) * main_next[69].clone().into()) * ((main_next[59].clone().into() - main_current[59].clone().into()) * main_next[69].clone().into() * (main_next[59].clone().into() - main_current[59].clone().into()) + (AB::Expr::ONE - (main_next[59].clone().into() - main_current[59].clone().into()) * main_next[69].clone().into()) * (main_next[62].clone().into() - main_current[62].clone().into())) - (main_next[68].clone().into() * AB::Expr::from_u64(65536) + main_next[67].clone().into()))); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (main_next[70].clone().into() - (AB::Expr::ONE - (main_next[58].clone().into() - main_current[58].clone().into()) * main_next[69].clone().into()) * (AB::Expr::ONE - (main_next[59].clone().into() - main_current[59].clone().into()) * main_next[69].clone().into()))); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (AB::Expr::ONE - (main_next[62].clone().into() - main_current[62].clone().into()) * main_next[69].clone().into()) * main_next[70].clone().into() * (AB::Expr::ONE - main_current[56].clone().into()) * (AB::Expr::ONE - main_next[56].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (main_next[56].clone().into() + (AB::Expr::ONE - main_next[56].clone().into()) * (AB::Expr::ONE - main_next[57].clone().into()) * (AB::Expr::ONE - (AB::Expr::ONE - main_next[61].clone().into()) * (AB::Expr::ONE - main_next[60].clone().into()))) * (main_next[70].clone().into() * (main_next[63].clone().into() - main_current[63].clone().into()) + (AB::Expr::ONE - main_next[70].clone().into()) * main_next[63].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (main_next[56].clone().into() + (AB::Expr::ONE - main_next[56].clone().into()) * (AB::Expr::ONE - main_next[57].clone().into()) * (AB::Expr::ONE - (AB::Expr::ONE - main_next[61].clone().into()) * main_next[60].clone().into())) * (main_next[70].clone().into() * (main_next[64].clone().into() - main_current[64].clone().into()) + (AB::Expr::ONE - main_next[70].clone().into()) * main_next[64].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (main_next[56].clone().into() + (AB::Expr::ONE - main_next[56].clone().into()) * (AB::Expr::ONE - main_next[57].clone().into()) * (AB::Expr::ONE - main_next[61].clone().into() * (AB::Expr::ONE - main_next[60].clone().into()))) * (main_next[70].clone().into() * (main_next[65].clone().into() - main_current[65].clone().into()) + (AB::Expr::ONE - main_next[70].clone().into()) * main_next[65].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_next[55].clone().into()) * (main_next[56].clone().into() + (AB::Expr::ONE - main_next[56].clone().into()) * (AB::Expr::ONE - main_next[57].clone().into()) * (AB::Expr::ONE - main_next[61].clone().into() * main_next[60].clone().into())) * (main_next[70].clone().into() * (main_next[66].clone().into() - main_current[66].clone().into()) + (AB::Expr::ONE - main_next[70].clone().into()) * main_next[66].clone().into())); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * (AB::Expr::ONE - main_current[55].clone().into()) * main_next[55].clone().into() * (AB::Expr::ONE - main_next[56].clone().into()) * (main_next[57].clone().into() - AB::Expr::ONE)); + builder.when_transition().assert_zero(main_current[53].clone().into() * main_current[54].clone().into() * main_current[55].clone().into() * (AB::Expr::ONE - main_current[56].clone().into()) * main_next[56].clone().into() * (AB::Expr::ONE - main_next[57].clone().into()) * (main_next[58].clone().into() - AB::Expr::ONE)); + builder.when_transition().assert_zero((main_next[52].clone().into() - main_current[52].clone().into()) * (main_next[52].clone().into() - main_current[52].clone().into() - AB::Expr::ONE) * (main_next[52].clone().into() - main_current[52].clone().into() - AB::Expr::from_u64(3)) * (main_next[52].clone().into() - main_current[52].clone().into() - AB::Expr::from_u64(9)) * (main_next[52].clone().into() - main_current[52].clone().into() - AB::Expr::from_u64(27)) * (main_next[52].clone().into() - main_current[52].clone().into() - AB::Expr::from_u64(81)) * (main_next[52].clone().into() - main_current[52].clone().into() - AB::Expr::from_u64(243)) * (main_next[52].clone().into() - main_current[52].clone().into() - AB::Expr::from_u64(729)) * (main_next[52].clone().into() - main_current[52].clone().into() - AB::Expr::from_u64(2187))); + + // Aux integrity/transition constraints + builder.when_transition().assert_zero_ext(((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[2].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[1].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[1].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[48].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[49].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[10].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[1].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[48].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[49].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[10].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[1].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[4].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[5].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[6].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[7].clone().into()) * beta_challenges[10].into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * AB::ExprEF::from(aux_current[0].clone().into()) - ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[1].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[1].into() + (AB::ExprEF::from(main_current[22].clone().into()) + AB::ExprEF::from(main_current[23].clone().into())) * AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[10].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::from(main_current[22].clone().into()) + AB::ExprEF::from(main_current[23].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::from(main_current[22].clone().into()) + AB::ExprEF::from(main_current[23].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[1].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[22].clone().into()) + AB::ExprEF::from(main_current[23].clone().into()))) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[22].clone().into()) + AB::ExprEF::from(main_current[23].clone().into())))) * AB::ExprEF::from(aux_next[0].clone().into())); + builder.when_transition().assert_zero_ext(((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into() + beta_challenges[5].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[22].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[23].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[32].clone().into()) * AB::ExprEF::from(main_current[16].clone().into()) + (AB::ExprEF::ONE - AB::ExprEF::from(main_current[32].clone().into())) * AB::ExprEF::from(main_current[20].clone().into())) * beta_challenges[1].into() + (AB::ExprEF::from(main_current[32].clone().into()) * AB::ExprEF::from(main_current[17].clone().into()) + (AB::ExprEF::ONE - AB::ExprEF::from(main_current[32].clone().into())) * AB::ExprEF::from(main_current[21].clone().into())) * beta_challenges[2].into() + (AB::ExprEF::from(main_current[32].clone().into()) * AB::ExprEF::from(main_current[18].clone().into()) + (AB::ExprEF::ONE - AB::ExprEF::from(main_current[32].clone().into())) * AB::ExprEF::from(main_current[22].clone().into())) * beta_challenges[3].into() + (AB::ExprEF::from(main_current[32].clone().into()) * AB::ExprEF::from(main_current[19].clone().into()) + (AB::ExprEF::ONE - AB::ExprEF::from(main_current[32].clone().into())) * AB::ExprEF::from(main_current[23].clone().into())) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into() + beta_challenges[6].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into()) * AB::ExprEF::from(main_current[32].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into()) * AB::ExprEF::from(main_current[32].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into() + beta_challenges[6].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * AB::ExprEF::from(aux_current[1].clone().into()) - ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into() + (AB::ExprEF::ONE - (AB::ExprEF::from(main_next[31].clone().into()) * AB::ExprEF::from(main_next[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[12].clone().into())) + AB::ExprEF::from(main_next[31].clone().into()) * AB::ExprEF::from(main_next[13].clone().into()) * AB::ExprEF::from(main_next[12].clone().into()) * AB::ExprEF::from(main_next[11].clone().into()))) * beta_challenges[5].into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[6].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(aux_next[1].clone().into())); + builder.when_transition().assert_zero_ext(((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[27].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[28].clone().into())) * AB::ExprEF::from(main_current[29].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[27].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[28].clone().into())) * AB::ExprEF::from(main_current[29].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[27].clone().into())) * AB::ExprEF::from(main_current[28].clone().into()) * AB::ExprEF::from(main_current[29].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[27].clone().into())) * AB::ExprEF::from(main_current[28].clone().into()) * AB::ExprEF::from(main_current[29].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::from_u64(2)) * beta_challenges[1].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[27].clone().into())) * AB::ExprEF::from(main_current[28].clone().into()) * AB::ExprEF::from(main_current[29].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[27].clone().into())) * AB::ExprEF::from(main_current[28].clone().into()) * AB::ExprEF::from(main_current[29].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::from_u64(3)) * beta_challenges[1].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[27].clone().into())) * AB::ExprEF::from(main_current[28].clone().into()) * AB::ExprEF::from(main_current[29].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[27].clone().into())) * AB::ExprEF::from(main_current[28].clone().into()) * AB::ExprEF::from(main_current[29].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::from_u64(2)) * beta_challenges[1].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::from_u64(3)) * beta_challenges[1].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::from_u64(4)) * beta_challenges[1].into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::from_u64(5)) * beta_challenges[1].into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::from_u64(6)) * beta_challenges[1].into() + AB::ExprEF::from(main_current[22].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::from_u64(7)) * beta_challenges[1].into() + AB::ExprEF::from(main_current[23].clone().into()) * beta_challenges[2].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(main_current[27].clone().into())) * AB::ExprEF::from(aux_current[2].clone().into()) - ((alpha.into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[25].clone().into()) * beta_challenges[1].into() + ((AB::ExprEF::from(main_next[16].clone().into()) * AB::ExprEF::from_u64(128) + AB::ExprEF::from(main_next[9].clone().into()) + AB::ExprEF::from(main_next[10].clone().into()).double() + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_next[11].clone().into()) + AB::ExprEF::from_u64(8) * AB::ExprEF::from(main_next[12].clone().into()) + AB::ExprEF::from_u64(16) * AB::ExprEF::from(main_next[13].clone().into()) + AB::ExprEF::from_u64(32) * AB::ExprEF::from(main_next[14].clone().into()) + AB::ExprEF::from_u64(64) * AB::ExprEF::from(main_next[15].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_next[32].clone().into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into())) * beta_challenges[2].into()) * AB::ExprEF::from(main_current[24].clone().into()) * (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::from(main_next[25].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[24].clone().into()) * (AB::ExprEF::from(main_current[25].clone().into()) - AB::ExprEF::from(main_next[25].clone().into()))) * AB::ExprEF::from(aux_next[2].clone().into())); + builder.when_transition().assert_zero_ext(((alpha.into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[47].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[49].clone().into()) * beta_challenges[2].into()) * ((AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) + AB::ExprEF::from(main_current[15].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[14].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - ((AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) + AB::ExprEF::from(main_current[15].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[14].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into()))) * AB::ExprEF::from(aux_current[3].clone().into()) - ((alpha.into() + AB::ExprEF::from(main_current[49].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[47].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[49].clone().into()) * beta_challenges[2].into()) * ((AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) + AB::ExprEF::from(main_current[15].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[14].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) + AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * AB::ExprEF::from(main_current[21].clone().into())) * (AB::ExprEF::from(main_current[48].clone().into()) - AB::ExprEF::from_u64(16)) * AB::ExprEF::from(main_current[50].clone().into()) + AB::ExprEF::ONE - ((AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) + AB::ExprEF::from(main_current[15].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[14].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) + AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) + AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * AB::ExprEF::from(main_current[21].clone().into())) * (AB::ExprEF::from(main_current[48].clone().into()) - AB::ExprEF::from_u64(16)) * AB::ExprEF::from(main_current[50].clone().into())) * ((alpha.into() + AB::ExprEF::from(main_current[49].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[47].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[2].into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) * (AB::ExprEF::from(main_current[48].clone().into()) - AB::ExprEF::from_u64(16)) * AB::ExprEF::from(main_current[50].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) * (AB::ExprEF::from(main_current[48].clone().into()) - AB::ExprEF::from_u64(16)) * AB::ExprEF::from(main_current[50].clone().into())) * AB::ExprEF::from(aux_next[3].clone().into())); + builder.when_transition().assert_zero_ext((alpha.into() + AB::ExprEF::from(main_current[52].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[0].into()) * AB::ExprEF::from(aux_current[4].clone().into()) + (alpha.into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[0].into()) * AB::ExprEF::from(main_current[51].clone().into()) - ((alpha.into() + AB::ExprEF::from(main_current[52].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[0].into()) * AB::ExprEF::from(aux_next[4].clone().into()) + (alpha.into() + AB::ExprEF::from(main_current[52].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[0].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) + (alpha.into() + AB::ExprEF::from(main_current[52].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[0].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) + (alpha.into() + AB::ExprEF::from(main_current[52].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[0].into()) * AB::ExprEF::from(main_current[15].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[14].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) + (alpha.into() + AB::ExprEF::from(main_current[52].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[0].into()) * AB::ExprEF::from(main_current[15].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[14].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) + (alpha.into() + AB::ExprEF::from(main_current[52].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[0].into()) * AB::ExprEF::from(main_current[15].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[14].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) + (alpha.into() + AB::ExprEF::from(main_current[52].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[0].into()) * (alpha.into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[0].into()) * AB::ExprEF::from(main_current[15].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[14].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())))); + builder.when_transition().assert_zero_ext(((alpha.into() + AB::ExprEF::from_u64(94) * beta_challenges[0].into() + AB::ExprEF::from(main_current[40].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[41].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[42].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[43].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[4].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()))) * ((alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[4].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) * ((alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[4].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()))) * ((alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[4].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) * AB::ExprEF::from(aux_current[5].clone().into()) - ((alpha.into() + AB::ExprEF::from_u64(94) * beta_challenges[0].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[4].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()))) * ((alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[4].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) * ((alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[4].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()))) * ((alpha.into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[4].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) * ((alpha.into() + AB::ExprEF::from_u64(28) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[7].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(12) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[3].into() + (AB::ExprEF::from(main_current[66].clone().into()) + AB::ExprEF::from(main_current[69].clone().into()) * AB::ExprEF::from_u64(1073741824) + (AB::ExprEF::from(main_current[62].clone().into()) + AB::ExprEF::ONE) * AB::ExprEF::from_u64(1152921504606846976)) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[58].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[58].clone().into())) * AB::ExprEF::from(aux_next[5].clone().into())); + builder.when_transition().assert_zero_ext(((alpha.into() + AB::ExprEF::from_u64(28) * beta_challenges[0].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[7].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())))) * ((alpha.into() + AB::ExprEF::from_u64(3) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into()) * (AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) + AB::ExprEF::ONE - (AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())))) * ((alpha.into() + AB::ExprEF::from_u64(16) * beta_challenges[0].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(3) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[5].into() + (AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::from(main_current[10].clone().into()).double() + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[11].clone().into()) + AB::ExprEF::from_u64(8) * AB::ExprEF::from(main_current[12].clone().into()) + AB::ExprEF::from_u64(16) * AB::ExprEF::from(main_current[13].clone().into()) + AB::ExprEF::from_u64(32) * AB::ExprEF::from(main_current[14].clone().into()) + AB::ExprEF::from_u64(64) * AB::ExprEF::from(main_current[15].clone().into())) * beta_challenges[10].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(8) * beta_challenges[0].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[33].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[34].clone().into()) * beta_challenges[5].into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(3) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[22].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[23].clone().into()) * beta_challenges[9].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(3) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[22].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[23].clone().into()) * beta_challenges[9].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + beta_challenges[0].into() + (AB::ExprEF::from(main_current[8].clone().into()) + AB::ExprEF::from_u64(7)) * beta_challenges[1].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[5].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(3) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[22].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[23].clone().into()) * beta_challenges[9].into() + (AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::from(main_current[10].clone().into()).double() + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[11].clone().into()) + AB::ExprEF::from_u64(8) * AB::ExprEF::from(main_current[12].clone().into()) + AB::ExprEF::from_u64(16) * AB::ExprEF::from(main_current[13].clone().into()) + AB::ExprEF::from_u64(32) * AB::ExprEF::from(main_current[14].clone().into()) + AB::ExprEF::from_u64(64) * AB::ExprEF::from(main_current[15].clone().into())) * beta_challenges[10].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(3) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[20].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[21].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[22].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[23].clone().into()) * beta_challenges[9].into() + (AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::from(main_current[10].clone().into()).double() + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[11].clone().into()) + AB::ExprEF::from_u64(8) * AB::ExprEF::from(main_current[12].clone().into()) + AB::ExprEF::from_u64(16) * AB::ExprEF::from(main_current[13].clone().into()) + AB::ExprEF::from_u64(32) * AB::ExprEF::from(main_current[14].clone().into()) + AB::ExprEF::from_u64(64) * AB::ExprEF::from(main_current[15].clone().into())) * beta_challenges[10].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(3) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[5].into() + (AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::from(main_current[10].clone().into()).double() + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[11].clone().into()) + AB::ExprEF::from_u64(8) * AB::ExprEF::from(main_current[12].clone().into()) + AB::ExprEF::from_u64(16) * AB::ExprEF::from(main_current[13].clone().into()) + AB::ExprEF::from_u64(32) * AB::ExprEF::from(main_current[14].clone().into()) + AB::ExprEF::from_u64(64) * AB::ExprEF::from(main_current[15].clone().into())) * beta_challenges[10].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(3) * beta_challenges[0].into() + AB::ExprEF::from(main_current[8].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[16].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[17].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[18].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[19].clone().into()) * beta_challenges[5].into() + (AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::from(main_current[10].clone().into()).double() + AB::ExprEF::from_u64(4) * AB::ExprEF::from(main_current[11].clone().into()) + AB::ExprEF::from_u64(8) * AB::ExprEF::from(main_current[12].clone().into()) + AB::ExprEF::from_u64(16) * AB::ExprEF::from(main_current[13].clone().into()) + AB::ExprEF::from_u64(32) * AB::ExprEF::from(main_current[14].clone().into()) + AB::ExprEF::from_u64(64) * AB::ExprEF::from(main_current[15].clone().into())) * beta_challenges[10].into()) * AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * AB::ExprEF::from(main_current[13].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(12) * beta_challenges[0].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[4].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[14].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[14].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + beta_challenges[0].into().double() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[33].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[3].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(6) * beta_challenges[0].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[33].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[3].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(28) * beta_challenges[0].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[33].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[34].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[35].clone().into()) * beta_challenges[7].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(4) * beta_challenges[0].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[33].clone().into()) * beta_challenges[4].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(20) * beta_challenges[0].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[33].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[34].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[35].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[36].clone().into()) * beta_challenges[7].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[15].clone().into())) * AB::ExprEF::from(main_current[14].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(9) * beta_challenges[0].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[33].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[34].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[35].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[36].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[37].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[38].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[39].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[40].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[41].clone().into()) * beta_challenges[10].into() + AB::ExprEF::from(main_current[42].clone().into()) * beta_challenges[11].into() + AB::ExprEF::from(main_current[43].clone().into()) * beta_challenges[12].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(11) * beta_challenges[0].into() + AB::ExprEF::from(main_current[38].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[39].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[40].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[41].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[10].clone().into())) * AB::ExprEF::from(main_current[9].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(9) * beta_challenges[0].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[33].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[34].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[35].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[36].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[37].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[38].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[39].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[40].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[41].clone().into()) * beta_challenges[10].into() + AB::ExprEF::from(main_current[42].clone().into()) * beta_challenges[11].into() + AB::ExprEF::from(main_current[43].clone().into()) * beta_challenges[12].into()) * AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[30].clone().into()) * AB::ExprEF::from(main_current[12].clone().into()) * AB::ExprEF::from(main_current[11].clone().into()) * AB::ExprEF::from(main_current[10].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[9].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(7) * beta_challenges[0].into() + AB::ExprEF::from(main_current[38].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[39].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[40].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[41].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(15) * beta_challenges[0].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[33].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[34].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[35].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[12].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(28) * beta_challenges[0].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[44].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[3].into() + (AB::ExprEF::from(main_next[32].clone().into()) - AB::ExprEF::from(main_current[32].clone().into())) * beta_challenges[4].into() + (AB::ExprEF::from(main_next[33].clone().into()) - AB::ExprEF::from(main_current[33].clone().into())) * beta_challenges[5].into() + (AB::ExprEF::from(main_next[34].clone().into()) - AB::ExprEF::from(main_current[34].clone().into())) * beta_challenges[6].into() + (AB::ExprEF::from(main_next[35].clone().into()) - AB::ExprEF::from(main_current[35].clone().into())) * beta_challenges[7].into()) * AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(28) * beta_challenges[0].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[1].into() + (AB::ExprEF::from(main_current[44].clone().into()) + AB::ExprEF::from_u64(4)) * beta_challenges[2].into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[3].into() + (AB::ExprEF::from(main_next[36].clone().into()) - AB::ExprEF::from(main_current[36].clone().into())) * beta_challenges[4].into() + (AB::ExprEF::from(main_next[37].clone().into()) - AB::ExprEF::from(main_current[37].clone().into())) * beta_challenges[5].into() + (AB::ExprEF::from(main_next[38].clone().into()) - AB::ExprEF::from(main_current[38].clone().into())) * beta_challenges[6].into() + (AB::ExprEF::from(main_next[39].clone().into()) - AB::ExprEF::from(main_current[39].clone().into())) * beta_challenges[7].into()) * AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(20) * beta_challenges[0].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[45].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[32].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[33].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[34].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[35].clone().into()) * beta_challenges[7].into()) * AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(20) * beta_challenges[0].into() + AB::ExprEF::from(main_current[2].clone().into()) * beta_challenges[1].into() + (AB::ExprEF::from(main_current[45].clone().into()) + AB::ExprEF::from_u64(4)) * beta_challenges[2].into() + AB::ExprEF::from(main_current[0].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[36].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[37].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[38].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[39].clone().into()) * beta_challenges[7].into()) * AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[31].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[13].clone().into())) * AB::ExprEF::from(main_current[12].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[11].clone().into()))) * AB::ExprEF::from(aux_current[6].clone().into()) - ((alpha.into() + AB::ExprEF::from_u64(3) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[0].clone().into()) + AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[10].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[11].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[12].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[13].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[14].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(3) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[0].clone().into()) + AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[10].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[11].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[12].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[13].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[14].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into()))) * ((alpha.into() + beta_challenges[0].into() + (AB::ExprEF::from(main_current[0].clone().into()) + AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[10].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(9) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[0].clone().into()) + AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[10].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[11].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[12].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[13].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[14].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[4].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(11) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[0].clone().into()) + AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[10].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()))) * ((alpha.into() + AB::ExprEF::from_u64(11) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[0].clone().into()) + AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[10].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) * ((alpha.into() + AB::ExprEF::from_u64(7) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[0].clone().into()) + AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[10].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()))) * ((alpha.into() + AB::ExprEF::from_u64(7) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[0].clone().into()) + AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[10].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) * ((alpha.into() + AB::ExprEF::from_u64(15) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[0].clone().into()) + AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[10].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()))) * ((alpha.into() + AB::ExprEF::from_u64(15) * beta_challenges[0].into() + (AB::ExprEF::from(main_current[0].clone().into()) + AB::ExprEF::ONE) * beta_challenges[1].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[7].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[8].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[9].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[10].into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double()) + AB::ExprEF::ONE - (AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into())) * AB::ExprEF::from(periodic_values[2].clone().into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::from(main_current[68].clone().into()) - AB::ExprEF::from(main_next[68].clone().into()).double())) * ((alpha.into() + beta_challenges[0].into().double() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[1].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[55].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[1].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(6) * beta_challenges[0].into() + AB::ExprEF::from(main_current[56].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[57].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into()) * AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[1].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[54].clone().into())) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(periodic_values[1].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(8) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[3].into() + (AB::ExprEF::from(main_current[63].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[69].clone().into())) * beta_challenges[4].into() + AB::ExprEF::from(main_current[69].clone().into()) * beta_challenges[5].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[57].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[57].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(48) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * AB::ExprEF::from(main_current[56].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into())) * AB::ExprEF::from(main_current[58].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * AB::ExprEF::from(main_current[56].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into())) * AB::ExprEF::from(main_current[58].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(16) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[60].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * AB::ExprEF::from(main_current[56].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * AB::ExprEF::from(main_current[56].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(28) * beta_challenges[0].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[1].into() + (AB::ExprEF::from(main_current[59].clone().into()) + AB::ExprEF::from(main_current[60].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()).double()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[7].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[55].clone().into())) * AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from(main_current[57].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[55].clone().into())) * AB::ExprEF::from(main_current[56].clone().into()) * AB::ExprEF::from(main_current[57].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(20) * beta_challenges[0].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[1].into() + (AB::ExprEF::from(main_current[59].clone().into()) + AB::ExprEF::from(main_current[60].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()).double()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[4].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[5].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[6].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[7].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[55].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[57].clone().into()) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[55].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[57].clone().into())) * ((alpha.into() + AB::ExprEF::from_u64(12) * beta_challenges[0].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[1].into() + (AB::ExprEF::from(main_current[59].clone().into()) + AB::ExprEF::from(main_current[60].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()).double()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[3].into() + ((AB::ExprEF::ONE - AB::ExprEF::from(main_current[61].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[60].clone().into())) * AB::ExprEF::from(main_current[63].clone().into()) + (AB::ExprEF::ONE - AB::ExprEF::from(main_current[61].clone().into())) * AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from(main_current[64].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[60].clone().into())) * AB::ExprEF::from(main_current[65].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from(main_current[66].clone().into())) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[55].clone().into())) * AB::ExprEF::from(main_current[56].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[55].clone().into())) * AB::ExprEF::from(main_current[56].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into()))) * ((alpha.into() + AB::ExprEF::from_u64(4) * beta_challenges[0].into() + AB::ExprEF::from(main_current[58].clone().into()) * beta_challenges[1].into() + (AB::ExprEF::from(main_current[59].clone().into()) + AB::ExprEF::from(main_current[60].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()).double()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[62].clone().into()) * beta_challenges[3].into() + ((AB::ExprEF::ONE - AB::ExprEF::from(main_current[61].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[60].clone().into())) * AB::ExprEF::from(main_current[63].clone().into()) + (AB::ExprEF::ONE - AB::ExprEF::from(main_current[61].clone().into())) * AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from(main_current[64].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[60].clone().into())) * AB::ExprEF::from(main_current[65].clone().into()) + AB::ExprEF::from(main_current[61].clone().into()) * AB::ExprEF::from(main_current[60].clone().into()) * AB::ExprEF::from(main_current[66].clone().into())) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[55].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into())) + AB::ExprEF::ONE - AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_next[55].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[57].clone().into()))) * AB::ExprEF::from(aux_next[6].clone().into())); + builder.when_transition().assert_zero_ext((alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[69].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[70].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[71].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(aux_current[7].clone().into()) + (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[69].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[70].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[71].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[72].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into())) + (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[69].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[70].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[71].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[71].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[58].clone().into())) + (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[69].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[70].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[71].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[72].clone().into()) * AB::ExprEF::from(main_current[58].clone().into()) - ((alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[69].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[70].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[71].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(aux_next[7].clone().into()) + (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[69].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[70].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[71].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[58].clone().into()) + (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[66].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[67].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[68].clone().into()) * beta_challenges[4].into()) * (alpha.into() + AB::ExprEF::from(main_current[61].clone().into()) * beta_challenges[0].into() + AB::ExprEF::from(main_current[59].clone().into()) * beta_challenges[1].into() + AB::ExprEF::from(main_current[63].clone().into()) * beta_challenges[2].into() + AB::ExprEF::from(main_current[64].clone().into()) * beta_challenges[3].into() + AB::ExprEF::from(main_current[65].clone().into()) * beta_challenges[4].into()) * AB::ExprEF::from(main_current[53].clone().into()) * AB::ExprEF::from(main_current[54].clone().into()) * AB::ExprEF::from(main_current[55].clone().into()) * (AB::ExprEF::ONE - AB::ExprEF::from(main_current[56].clone().into())) * AB::ExprEF::from(main_current[58].clone().into()))); + } +} \ No newline at end of file diff --git a/constraints/range_checker.air b/constraints/range_checker.air new file mode 100644 index 000000000..6aafb7808 --- /dev/null +++ b/constraints/range_checker.air @@ -0,0 +1,105 @@ +########################################################################################## +# RANGE CHECKER CONSTRAINTS MODULE +########################################################################################## +# +# The Range Checker provides efficient 16-bit range checking for other VM components +# using the LogUp protocol with optimized gap handling to minimize the minimal +# trace length while supporting (practically) unlimited range checks. +# +# STATUS: Fully implemented +# +# REFERENCES: +# - Range Checker Spec: https://0xmiden.github.io/miden-vm/design/range.html +# - LogUp Protocol: https://0xmiden.github.io/miden-vm/design/lookups/main.html +########################################################################################## + +mod range_checker + +use chiplets::*; +use utils::*; + +########################################################################################## +# RANGE CHECKER CONSTRAINTS +########################################################################################## + +ev range_checker_constraints([decoder[24], range_checker[2], chiplets[20]]) { + + #################################################################################### + # COLUMN DEFINITIONS + #################################################################################### + + # Range checker table columns + let value = range_checker[1]; # v: Current 16-bit value [0, 65535] + let multiplicity = range_checker[0]; # m: Usage count (how many times v is range-checked) + + # Stack values requiring 16-bit range checks (from decoder trace) + # These correspond to the top 4 operand stack elements during u32 operations + let sv0 = decoder[10]; # Stack value 0 + let sv1 = decoder[11]; # Stack value 1 + let sv2 = decoder[12]; # Stack value 2 + let sv3 = decoder[13]; # Stack value 3 + + # Memory chiplet values requiring 16-bit range checks + let mem_d0 = chiplets[14]; # Memory delta 0 (low 16 bits) + let mem_d1 = chiplets[15]; # Memory delta 1 (high 16 bits) + + #################################################################################### + # OPERATION FLAGS - Determine when range checks are needed + #################################################################################### + + # U32 range check operation flag + # Identifies stack operations that require 16-bit range checking + let not_4 = binary_not(decoder[5]); + let not_5 = binary_not(decoder[6]); + let u32_rc_op = decoder[7] * not_4 * not_5; + + # Memory chiplet operation flag + # Identifies memory operations that require range checking + let s_0 = chiplets[0]; + let s_1 = chiplets[1]; + let s_2 = chiplets[2]; + let chiplets_memory_flag = memory_chiplet_flag(s_0, s_1, s_2); + + #################################################################################### + # TRANSITION CONSTRAINTS + #################################################################################### + + # Value transition constraint - Gap handling with powers of 3 + # The value column must increase monotonically, with gaps that are powers of 3. + # This optimization allows the table to skip unused values, reducing trace length + # from a required 65,536 rows to a much smaller number based on actual usage. + # Allowed deltas: {0, 1, 3, 9, 27, 81, 243, 729, 2187} + # Constraint degree: 9 + let delta = value' - value; + enf delta * (delta - 1) * (delta - 3) * (delta - 9) * (delta - 27) + * (delta - 81) * (delta - 243) * (delta - 729) * (delta - 2187) = 0; + + #################################################################################### + # BUS OPERATIONS + #################################################################################### + # The range checker provides responses to range check requests via the LogUp + # protocol (bus_4_range_checker). The LogUp protocol ensures that all values + # requested for range checking (from stack u32 operations and memory chiplet) + # are present in the range checker table with appropriate multiplicities. + # + # The auxiliary column constraint for the LogUp bus is automatically generated + # by the AIR-script compiler from these insert/remove operations: + # b_range' = b_range + m/(α + v) [table provides values] + # - flag_u32_op/(α + sv0) - ... [stack requests checks] + # - flag_mem/(α + mem_d0) - ... [memory requests checks] + # where α is a random challenge from the verifier. + #################################################################################### + + # Table provides: Each cycle, insert the current value with its multiplicity + bus_4_range_checker.insert(value) with multiplicity; + + # Memory requests: When memory operations occur, verify values are 16-bit + bus_4_range_checker.remove(mem_d0) when chiplets_memory_flag; + bus_4_range_checker.remove(mem_d1) when chiplets_memory_flag; + + # Stack requests: When u32 operations occur, verify operand components are 16-bit + bus_4_range_checker.remove(sv0) when u32_rc_op; + bus_4_range_checker.remove(sv1) when u32_rc_op; + bus_4_range_checker.remove(sv2) when u32_rc_op; + bus_4_range_checker.remove(sv3) when u32_rc_op; +} diff --git a/constraints/rpo.air b/constraints/rpo.air new file mode 100644 index 000000000..5061e8188 --- /dev/null +++ b/constraints/rpo.air @@ -0,0 +1,110 @@ + +mod rpo + +########################################################################################## +# RPO PERMUTATION ROUND CONSTRAINTS +########################################################################################## + +ev enforce_rpo_round([h[12]]){ + let ark1 = [ark1_0, ark1_1, ark1_2, ark1_3, ark1_4, ark1_5, ark1_6, ark1_7, ark1_8, ark1_9, + ark1_10, ark1_11]; + + let ark2 = [ark2_0, ark2_1, ark2_2, ark2_3, ark2_4, ark2_5, ark2_6, ark2_7, ark2_8, ark2_9, + ark2_10, ark2_11]; + + # Compute the state that should result from applying the first 5 steps of an RPO round to + # the current hasher state. + + # 1. Apply mds + let step1_initial = apply_mds(h); + + # 2. Add constants + let step1_with_constants = [s + k for (s, k) in (step1_initial, ark1)]; + + # 3. Apply sbox + let step1_with_sbox = [s^7 for s in step1_with_constants]; + + # 4. Apply mds + let step1_with_mds = apply_mds(step1_with_sbox); + + # 5. Add constants + let step1 = [s + k for (s, k) in (step1_with_mds, ark2)]; + + # Compute the state that should result from applying the inverse of the last operation of the + # RPO round to the next step of the computation. + let step2 = [s'^7 for s in h]; + + # Make sure that the results are equal. + enf s1 = s2 for (s1, s2) in (step1, step2); +} + +########################################################################################## +# HELPER FUNCTIONS +########################################################################################## + +fn apply_mds(state: felt[12]) -> felt[12]{ + # Compute dot product of state vector with each MDS row + let result0 = sum([s * m for (s, m) in (state, MDSROWA)]); + let result1 = sum([s * m for (s, m) in (state, MDSROWB)]); + let result2 = sum([s * m for (s, m) in (state, MDSROWC)]); + let result3 = sum([s * m for (s, m) in (state, MDSROWD)]); + let result4 = sum([s * m for (s, m) in (state, MDSROWE)]); + let result5 = sum([s * m for (s, m) in (state, MDSROWF)]); + let result6 = sum([s * m for (s, m) in (state, MDSROWG)]); + let result7 = sum([s * m for (s, m) in (state, MDSROWH)]); + let result8 = sum([s * m for (s, m) in (state, MDSROWI)]); + let result9 = sum([s * m for (s, m) in (state, MDSROWJ)]); + let result10 = sum([s * m for (s, m) in (state, MDSROWK)]); + let result11 = sum([s * m for (s, m) in (state, MDSROWL)]); + + return [result0, result1, result2, result3, result4, result5, + result6, result7, result8, result9, result10, result11]; +} + +########################################################################################## +# CONSTANTS AND PERIODIC COLUMNS +########################################################################################## + +# MDS matrix rows used for computing the linear layer in a RPO round +const MDSROWA = [7, 23, 8, 26, 13, 10, 9, 7, 6, 22, 21, 8]; +const MDSROWB = [8, 7, 23, 8, 26, 13, 10, 9, 7, 6, 22, 21]; +const MDSROWC = [21, 8, 7, 23, 8, 26, 13, 10, 9, 7, 6, 22]; +const MDSROWD = [22, 21, 8, 7, 23, 8, 26, 13, 10, 9, 7, 6]; +const MDSROWE = [6, 22, 21, 8, 7, 23, 8, 26, 13, 10, 9, 7]; +const MDSROWF = [7, 6, 22, 21, 8, 7, 23, 8, 26, 13, 10, 9]; +const MDSROWG = [9, 7, 6, 22, 21, 8, 7, 23, 8, 26, 13, 10]; +const MDSROWH = [10, 9, 7, 6, 22, 21, 8, 7, 23, 8, 26, 13]; +const MDSROWI = [13, 10, 9, 7, 6, 22, 21, 8, 7, 23, 8, 26]; +const MDSROWJ = [26, 13, 10, 9, 7, 6, 22, 21, 8, 7, 23, 8]; +const MDSROWK = [8, 26, 13, 10, 9, 7, 6, 22, 21, 8, 7, 23]; +const MDSROWL = [23, 8, 26, 13, 10, 9, 7, 6, 22, 21, 8, 7]; + +periodic_columns{ + # Round constants added to the hasher state in the first half of the RPO round + ark1_0: [5789762306288267264, 12987190162843097088, 18072785500942327808, 5674685213610122240, 4887609836208846848, 16308865189192448000, 7123075680859040768, 0], + ark1_1: [6522564764413702144, 653957632802705280, 6200974112677013504, 5759084860419474432, 3027115137917284352, 11977192855656443904, 1034205548717903104, 0], + ark1_2: [17809893479458207744, 4441654670647621120, 17682092219085883392, 13943282657648898048, 9595098600469471232, 12532242556065779712, 7717824418247931904, 0], + ark1_3: [107145243989736512, 4038207883745915904, 10599526828986757120, 1352748651966375424, 10528569829048483840, 14594890931430969344, 3019070937878604288, 0], + ark1_4: [6388978042437517312, 5613464648874829824, 975003873302957312, 17110913224029904896, 7864689113198940160, 7291784239689209856, 11403792746066868224, 0], + ark1_5: [15844067734406017024, 13222989726778339328, 8264241093196931072, 1003883795902368384, 17533723827845969920, 5514718540551361536, 10280580802233112576, 0], + ark1_6: [9975000513555218432, 3037761201230264320, 10065763900435474432, 4141870621881018368, 5781638039037711360, 10025733853830934528, 337153209462421248, 0], + ark1_7: [3344984123768313344, 16683759727265179648, 2181131744534710272, 8121410972417424384, 17024078752430718976, 7293794580341021696, 13333398568519923712, 0], + ark1_8: [9959189626657347584, 8337364536491240448, 6317303992309419008, 14300518605864919040, 109659393484013504, 6728552937464861696, 3596153696935337472, 0], + ark1_9: [12960773468763564032, 3227397518293416448, 1401440938888741632, 13712227150607669248, 7158933660534805504, 6332385040983343104, 8104208463525993472, 0], + ark1_10: [9602914297752487936, 8110510111539675136, 8884468225181997056, 17021852944633065472, 2955076958026921984, 13277683694236792832, 14345062289456084992, 0], + ark1_11: [16657542370200465408, 2872078294163232256, 13066900325715521536, 6252096473787587584, 7433723648458773504, 2600778905124452864, 17036731477169661952, 0], + + # Round constants added to the hasher state in the second half of the RPO round + ark2_0: [6077062762357203968, 6202948458916100096, 8023374565629191168, 18389244934624493568, 6982293561042363392, 3736792340494631424, 17130398059294019584, 0], + ark2_1: [15277620170502010880, 17690140365333231616, 15013690343205953536, 16731736864863924224, 14065426295947720704, 577852220195055360, 519782857322262016, 0], + ark2_2: [5358738125714196480, 3595001575307484672, 4485500052507913216, 4440209734760478208, 16451845770444974080, 6689998335515780096, 9625384390925084672, 0], + ark2_3: [14233283787297595392, 373995945117666496, 12489737547229155328, 17208448209698889728, 7139138592091307008, 13886063479078012928, 1664893052631119104, 0], + ark2_4: [13792579614346651648, 1235734395091296000, 9500452585969031168, 8739495587021565952, 9012006439959783424, 14358505101923203072, 7629576092524553216, 0], + ark2_5: [11614812331536766976, 14172757457833930752, 2054001340201038848, 17000774922218162176, 14619614108529063936, 7744142531772273664, 3485239601103661568, 0], + ark2_6: [14871063686742261760, 707573103686350208, 12420704059284934656, 13533282547195531264, 1394813199588124416, 16135070735728404480, 9755891797164034048, 0], + ark2_7: [10148237148793042944, 15453217512188186624, 355990932618543744, 525402848358706240, 4635111139507788800, 12290902521256030208, 15218148195153268736, 0], + ark2_8: [4457428952329675776, 219777875004506016, 9071225051243524096, 16987541523062161408, 16217473952264204288, 12059913662657710080, 16460604813734957056, 0], + ark2_9: [15590786458219171840, 17876696346199468032, 12766199826003447808, 5466806524462796800, 10782018226466330624, 16456018495793752064, 9643968136937730048, 0], + ark2_10: [10063319113072093184, 17731621626449383424, 9045979173463557120, 14512769585918244864, 6844229992533661696, 4571485474751953408, 3611348709641382912, 0], + ark2_11: [14200078843431360512, 2897136237748376064, 12934431667190679552, 10973956031244050432, 7446486531695178752, 17200392109565784064, 18256379591337758720, 0], +} diff --git a/constraints/stack.air b/constraints/stack.air new file mode 100644 index 000000000..0a25c53f3 --- /dev/null +++ b/constraints/stack.air @@ -0,0 +1,2210 @@ +########################################################################################## +# MIDEN VM - OPERAND STACK CONSTRAINTS +########################################################################################## +# +# This module implements the stack constraints following the Miden VM specification: +# https://0xmiden.github.io/miden-vm/design/stack/main.html +# +########################################################################################## + +mod stack + +use decoder::*; +use utils::*; + +########################################################################################## +# STACK TRACE LAYOUT +########################################################################################## +# +# The stack trace consists of 19 columns: +# - s0-s15: Stack elements (16 columns) - top 16 elements always visible +# - b0: Stack depth (must be ≥ 16) +# - b1: Overflow table address (when depth > 16) +# - h0: Helper column (witness for depth > 16) +# +########################################################################################## + +# Main stack constraint evaluator with decoder integration +ev stack([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, b0, b1, h0, + decoder_addr, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, + decoder_h0, decoder_h1, decoder_h2, decoder_h3, decoder_h4, decoder_h5, decoder_h6, decoder_h7, + decoder_sp, decoder_gc, decoder_ox, decoder_c0, decoder_c1, decoder_c2, decoder_e0, decoder_e1, + system_clk, system_fmp, system_ctx, system_fn_hash_0, system_fn_hash_1, system_fn_hash_2, system_fn_hash_3]) { + # Stack element columns (always visible top 16 elements) + # s0-s15 are the top 16 stack elements (s0 = top of stack) + # b0 = stack depth (≥ 16) + # b1 = overflow table address + # h0 = helper column (witness) + + #################################################################################### + # STACK GENERAL CONSTRAINTS + #################################################################################### + + enf stack_general_constraints([s15, b0, b1, h0, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, + decoder_h5, decoder_e0, decoder_e1, system_clk]); + + #################################################################################### + # OPERATION-SPECIFIC CONSTRAINTS + #################################################################################### + + enf stack_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, + b0, b1, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, + decoder_h0, decoder_h1, decoder_h2, decoder_h3, decoder_h4, decoder_h5, + decoder_e0, decoder_e1, system_clk, system_fmp, system_ctx, + system_fn_hash_0, system_fn_hash_1, system_fn_hash_2, system_fn_hash_3]); + +} + +########################################################################################## +# GENERAL CONSTRAINTS +########################################################################################## + +# Unified stack general constraints evaluator +ev stack_general_constraints([s15, b0, b1, h0, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, + decoder_h5, decoder_e0, decoder_e1, system_clk]) { + + # 1. STACK OVERFLOW FLAG CONSTRAINTS + enf stack_overflow_flag([b0, h0]); + + # 2. STACK DEPTH CONSTRAINTS + enf stack_depth_constraints([b0, h0, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, + decoder_h5, decoder_e0, decoder_e1]); + + # 3. RIGHT SHIFT B1 CONSTRAINT + enf right_shift_b1_constraint([b1, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, decoder_e0, decoder_e1, system_clk]); + + # 4. LEFT SHIFT ZERO INSERTION CONSTRAINT + enf left_shift_zero_insertion([s15, b0, h0, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, + decoder_h5, decoder_e0, decoder_e1]); + + # 5. STACK OVERFLOW BUS CONSTRAINTS + # + # Tracks rows pushed to and popped from the overflow table: + # - Right shift: push (clk, s15, b1) + # - Left shift: pop (b1, s15', b1') when overflow is non-empty + # - DYNCALL: pop (b1, s15', h5) when overflow is non-empty + let depth_excess = b0 - 16; + let fov = depth_excess * h0; + + let op_bits = [decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6]; + let fshr = flag_shr(op_bits, decoder_e0, decoder_e1); + let fshl = flag_shl(op_bits, decoder_h5, decoder_e0, decoder_e1); + let fdyncall = flag_dyncall(op_bits, decoder_e0); + + bus_3_stack_p1.insert(system_clk, s15, b1) when fshr; + bus_3_stack_p1.remove(b1, s15', b1') when (fshl * fov); + bus_3_stack_p1.remove(b1, s15', decoder_h5) when (fdyncall * fov); +} + +# Stack overflow flag constraint +# Constraint: (1−fov)⋅(b0−16)=0 | degree=3 +ev stack_overflow_flag([b0, h0]) { + # The overflow flag fov is computed using helper column h0 as witness: + # - When b0 = 16: h0 = 0, so fov = 0 + # - When b0 > 16: h0 = (b0-16)^(-1), so fov = 1 + + let depth_excess = b0 - 16; + let fov = depth_excess * h0; + + # Helper column witness constraint: ensures h0 is either 0 or inverse of (b0-16) + # When depth_excess ≠ 0, this forces fov = 1, meaning h0 = (depth_excess)^(-1) + # When depth_excess = 0, this constraint is automatically satisfied + enf depth_excess * (1 - fov) = 0; +} + +# Left shift zero insertion constraint +# Constraint: fshl⋅(1−fov)⋅s15′=0 | degree=8 +ev left_shift_zero_insertion([s15, b0, h0, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, decoder_h5, decoder_e0, decoder_e1]) { + # When fshl=1 and fov=0 (i.e., left shift when depth=16), s15' must be 0 + + # Compute overflow flag using helper column witness + let depth_excess = b0 - 16; + let fov = depth_excess * h0; + + # Use helper function to compute left shift flag + let op_bits = [decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6]; + let fshl = flag_shl(op_bits, decoder_h5, decoder_e0, decoder_e1); + + # Official left shift zero insertion constraint: fshl⋅(1−fov)⋅s15′=0 + let constraint = fshl * (1 - fov) * s15'; + + enf constraint = 0; +} + +# Stack depth constraint +ev stack_depth_constraints([b0, h0, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, decoder_h5, decoder_e0, decoder_e1]) { + # Compute overflow flag using helper column witness + let depth_excess = b0 - 16; + let fov = depth_excess * h0; + + # Use helper functions to compute stack shift flags + let op_bits = [decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6]; + let fshl = flag_shl(op_bits, decoder_h5, decoder_e0, decoder_e1); + let fshr = flag_shr(op_bits, decoder_e0, decoder_e1); + + # Stack depth constraint + # depth decreases if overflow table is not empty on shift-left ops + # depth increases on shift-right ops + enf b0' - b0 - fshr + fshl * fov = 0; +} + +# Right shift B1 constraint +ev right_shift_b1_constraint([b1, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, decoder_e0, decoder_e1, system_clk]) { + # Official constraint: fshr⋅(b1′−k0)=0 | degree=7 + # Ensures b1 is set to current clock cycle during right shifts + + # Use helper function to compute right shift flag + let op_bits = [decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6]; + let fshr = flag_shr(op_bits, decoder_e0, decoder_e1); + + # k0 is the current clock cycle from system column + let k0 = system_clk; + + # Official right shift B1 constraint: fshr⋅(b1′−k0)=0 + # When fshr=1 (right shift operation), b1' must equal k0 (current clock cycle) + let constraint = fshr * (b1' - k0); + + enf constraint = 0; +} + +########################################################################################## +# OPERATION-SPECIFIC STACK CONSTRAINTS +########################################################################################## + +# Stack-manipulation constraints mirror the implementation grouping: +# PAD/DUP*/CLK, SWAP, MOVUP2..MOVUP8, MOVDN2..MOVDN8, SWAPW/SWAPW2/SWAPW3/SWAPDW, CSWAP/CSWAPW. +# The per-op constraints below are listed in opcode order but cover the same groups. + +# Applies the appropriate operation-specific constraints based on active operation flags +ev stack_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, + stack_b0, stack_b1, decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6, + decoder_h0, decoder_h1, decoder_h2, decoder_h3, decoder_h4, decoder_h5, + decoder_e0, decoder_e1, + system_clk, system_fmp, system_ctx, + system_fn_hash_0, system_fn_hash_1, system_fn_hash_2, system_fn_hash_3 + ]) + { + + let op_bits = [decoder_b0, decoder_b1, decoder_b2, decoder_b3, decoder_b4, decoder_b5, decoder_b6]; + + # Apply operation-specific constraints using match pattern + # The op flags are mutually exclusive and hence only one operation will be active at a time + # and only one set of constraints applies + + # Operations ordered following the Miden VM specification table + # Group 1: No stack shift operations (opcodes 0-31) - in specification order + let is_noop = flag_noop(op_bits); # Opcode 0 + let is_eqz = flag_eqz(op_bits); # Opcode 1 + let is_neg = flag_neg(op_bits); # Opcode 2 + let is_inv = flag_inv(op_bits); # Opcode 3 + let is_incr = flag_incr(op_bits); # Opcode 4 + let is_not = flag_not(op_bits); # Opcode 5 + let is_mload = flag_mload(op_bits); # Opcode 7 + let is_swap = flag_swap(op_bits); # Opcode 8 + let is_caller = flag_caller(op_bits); # Opcode 9 + let is_movup2 = flag_movup2(op_bits); # Opcode 10 + let is_movdn2 = flag_movdn2(op_bits); # Opcode 11 + let is_movup3 = flag_movup3(op_bits); # Opcode 12 + let is_movdn3 = flag_movdn3(op_bits); # Opcode 13 + let is_advpopw = flag_advpopw(op_bits); # Opcode 14 + let is_expacc = flag_expacc(op_bits); # Opcode 15 + let is_movup4 = flag_movup4(op_bits); # Opcode 16 + let is_movdn4 = flag_movdn4(op_bits); # Opcode 17 + let is_movup5 = flag_movup5(op_bits); # Opcode 18 + let is_movdn5 = flag_movdn5(op_bits); # Opcode 19 + let is_movup6 = flag_movup6(op_bits); # Opcode 20 + let is_movdn6 = flag_movdn6(op_bits); # Opcode 21 + let is_movup7 = flag_movup7(op_bits); # Opcode 22 + let is_movdn7 = flag_movdn7(op_bits); # Opcode 23 + let is_swapw = flag_swapw(op_bits); # Opcode 24 + let is_ext2mul = flag_ext2mul(op_bits); # Opcode 25 + let is_movup8 = flag_movup8(op_bits); # Opcode 26 + let is_movdn8 = flag_movdn8(op_bits); # Opcode 27 + let is_swapw2 = flag_swapw2(op_bits); # Opcode 28 + let is_swapw3 = flag_swapw3(op_bits); # Opcode 29 + let is_swapdw = flag_swapdw(op_bits); # Opcode 30 + let is_emit = flag_emit(op_bits); # Opcode 31 + + # Group 2: Left stack shift operations - ordered by Miden VM specification (opcodes 32-47) + let is_assert = flag_assert(op_bits); # Opcode 32 + let is_eq = flag_eq(op_bits); # Opcode 33 + let is_add = flag_add(op_bits); # Opcode 34 + let is_mul = flag_mul(op_bits); # Opcode 35 + let is_and = flag_and(op_bits); # Opcode 36 + let is_or = flag_or(op_bits); # Opcode 37 + let is_u32and = flag_u32and(op_bits); # Opcode 38 + let is_u32xor = flag_u32xor(op_bits); # Opcode 39 + let is_frie2f4 = flag_frie2f4(op_bits); # Opcode 40 + let is_drop = flag_drop(op_bits); # Opcode 41 + let is_cswap = flag_cswap(op_bits); # Opcode 42 + let is_cswapw = flag_cswapw(op_bits); # Opcode 43 + let is_mloadw = flag_mloadw(op_bits); # Opcode 44 + let is_mstore = flag_mstore(op_bits); # Opcode 45 + let is_mstorew = flag_mstorew(op_bits); # Opcode 46 + + # Group 3: Right stack shift operations - ordered by Miden VM specification (opcodes 48-63) + let is_pad = flag_pad(op_bits); # Opcode 48 + let is_dup = flag_dup(op_bits); # Opcode 49 + let is_dup1 = flag_dup1(op_bits); # Opcode 50 + let is_dup2 = flag_dup2(op_bits); # Opcode 51 + let is_dup3 = flag_dup3(op_bits); # Opcode 52 + let is_dup4 = flag_dup4(op_bits); # Opcode 53 + let is_dup5 = flag_dup5(op_bits); # Opcode 54 + let is_dup6 = flag_dup6(op_bits); # Opcode 55 + let is_dup7 = flag_dup7(op_bits); # Opcode 56 + let is_dup9 = flag_dup9(op_bits); # Opcode 57 + let is_dup11 = flag_dup11(op_bits); # Opcode 58 + let is_dup13 = flag_dup13(op_bits); # Opcode 59 + let is_dup15 = flag_dup15(op_bits); # Opcode 60 + let is_advpop = flag_advpop(op_bits); # Opcode 61 + let is_sdepth = flag_sdepth(op_bits); # Opcode 62 + let is_clk = flag_clk(op_bits); # Opcode 63 + + # Group 3.5: u32 operations (opcodes 64-78, binary prefix 100) + let is_u32add = flag_u32add(op_bits); # Opcode 64: 100_0000 + let is_u32sub = flag_u32sub(op_bits); # Opcode 66: 100_0010 + let is_u32mul = flag_u32mul(op_bits); # Opcode 68: 100_0100 + let is_u32div = flag_u32div(op_bits); # Opcode 70: 100_0110 + let is_u32split = flag_u32split(op_bits); # Opcode 72: 100_1000 + let is_u32assert2 = flag_u32assert2(op_bits); # Opcode 74: 100_1010 + let is_u32add3 = flag_u32add3(op_bits); # Opcode 76: 100_1100 + let is_u32madd = flag_u32madd(op_bits); # Opcode 78: 100_1110 + + # Group 4: High-degree operations (101 group) - requires e0 for degree reduction + let is_hperm = flag_hperm(op_bits, decoder_e0); # Opcode 80 (101_0000) + let is_mpverify = flag_mpverify(op_bits, decoder_e0); # Opcode 81 (101_0001) + let is_pipe = flag_pipe(op_bits, decoder_e0); # Opcode 82 (101_0010) + let is_mstream = flag_mstream(op_bits, decoder_e0); # Opcode 83 (101_0011) + let is_split = flag_split(op_bits, decoder_e0); # Opcode 84 (101_0100) + let is_loop = flag_loop(op_bits, decoder_e0); # Opcode 85 (101_0101) + let is_dyn = flag_dyn(op_bits, decoder_e0); # Opcode 88 (101_1000) + let is_hornerext = flag_hornerext(op_bits, decoder_e0); # Opcode 90 (101_1010) + let is_push = flag_push(op_bits, decoder_e0); # Opcode 91 (101_1011) + let is_dyncall = flag_dyncall(op_bits, decoder_e0); # Opcode 92 (101_1100) + let is_evalcircuit = flag_evalcircuit(op_bits, decoder_e0); # Opcode 93 (101_1101) + let is_logprecompile = flag_logprecompile(op_bits, decoder_e0); # Opcode 94 (101_1110) + + # Group 5: Very high-degree operations (110 group) - requires e1 for degree reduction + let is_mrupdate = flag_mrupdate(op_bits, decoder_e1); # Opcode 96 (110_0000) + let is_cryptostream = flag_cryptostream(op_bits, decoder_e1); # Opcode 100 (110_0100) + let is_hornerbase = flag_hornerbase(op_bits, decoder_e0); # Opcode 89 (101_1001) + let is_syscall = flag_syscall(op_bits, decoder_e1); # Opcode 104 (110_1000) + let is_call = flag_call(op_bits, decoder_e1); # Opcode 108 (110_1100) + + enf match { + # No stack shift operations - ordered by Miden VM specification (opcodes 0-31) + case is_noop: noop_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 0 + case is_eqz: eqz_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0]),# 1 + case is_neg: neg_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 2 + case is_inv: inv_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 3 + case is_incr: incr_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 4 + case is_not: not_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 5 + case is_mload: mload_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_ctx, system_clk]), # 7 + case is_swap: swap_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 8 + case is_caller: caller_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_fn_hash_0, system_fn_hash_1, system_fn_hash_2, system_fn_hash_3]), # 9 + case is_movup2: movup2_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 10 + case is_movdn2: movdn2_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 11 + case is_movup3: movup3_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 12 + case is_movdn3: movdn3_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 13 + case is_advpopw: advpopw_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 14 + case is_expacc: expacc_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0]), # 15 + case is_movup4: movup4_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 16 + case is_movdn4: movdn4_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 17 + case is_movup5: movup5_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 18 + case is_movdn5: movdn5_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 19 + case is_movup6: movup6_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 20 + case is_movdn6: movdn6_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 21 + case is_movup7: movup7_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 22 + case is_movdn7: movdn7_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 23 + case is_swapw: swapw_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 24 + case is_ext2mul: ext2mul_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 25 + case is_movup8: movup8_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 26 + case is_movdn8: movdn8_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 27 + case is_swapw2: swapw2_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 28 + case is_swapw3: swapw3_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 29 + case is_swapdw: swapdw_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 30 + case is_emit: emit_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 31 + + # Left stack shift operations - ordered by Miden VM specification (opcodes 32-47) + case is_assert: assert_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 32 + case is_eq: eq_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0]), # 33 + case is_add: add_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 34 + case is_mul: mul_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 35 + case is_and: and_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 36 + case is_or: or_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 37 + case is_u32and: u32and_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 38 + case is_u32xor: u32xor_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 39 + case is_frie2f4: frie2f4_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3, decoder_h4, decoder_h5]), # 40 + case is_drop: drop_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 41 + case is_cswap: cswap_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 42 + case is_cswapw: cswapw_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 43 + case is_mloadw: mloadw_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_ctx, system_clk]), # 44 + case is_mstore: mstore_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_ctx, system_clk]), # 45 + case is_mstorew: mstorew_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_ctx, system_clk]), # 46 + + # Right stack shift operations - ordered by Miden VM specification (opcodes 48-63) + case is_pad: pad_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 48 + case is_dup: dup_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 49 + case is_dup1: dup1_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 50 + case is_dup2: dup2_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 51 + case is_dup3: dup3_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 52 + case is_dup4: dup4_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 53 + case is_dup5: dup5_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 54 + case is_dup6: dup6_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 55 + case is_dup7: dup7_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 56 + case is_dup9: dup9_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 57 + case is_dup11: dup11_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 58 + case is_dup13: dup13_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 59 + case is_dup15: dup15_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 60 + case is_advpop: advpop_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 61 + case is_sdepth: sdepth_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, stack_b0]), # 62 + case is_clk: clk_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_clk]), # 63 + + # u32 operations (100 group) + case is_u32add: u32add_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3]), # 64 + case is_u32sub: u32sub_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3]), # 66 + case is_u32mul: u32mul_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3, decoder_h4]), # 68 + case is_u32div: u32div_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3]), # 70 + case is_u32split: u32split_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3, decoder_h4]), # 72 + case is_u32assert2: u32assert2_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3]), # 74 + case is_u32add3: u32add3_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3]), # 76 + case is_u32madd: u32madd_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3, decoder_h4]), # 78 + + # High-degree operations (101 group) + case is_hperm: hperm_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 80 + case is_mpverify: mpverify_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 81 + case is_pipe: pipe_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 82 + case is_mstream: mstream_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 83 + case is_split: split_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 84 + case is_loop: loop_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 85 + case is_dyn: dyn_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 88 + case is_hornerext: hornerext_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3, decoder_h4, decoder_h5]), # 90 + case is_push: push_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 91 + case is_dyncall: dyncall_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, stack_b0, stack_b1]), # 92 + case is_evalcircuit: evalcircuit_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 93 + case is_logprecompile: logprecompile_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, + decoder_h0, decoder_h1, decoder_h2, decoder_h3, decoder_h4]), # 94 + + # Very high-degree operations (110 group) + case is_mrupdate: mrupdate_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]), # 96 + case is_cryptostream: cryptostream_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_ctx, system_clk]), # 100 + case is_hornerbase: hornerbase_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, decoder_h0, decoder_h1, decoder_h2, decoder_h3, decoder_h4, decoder_h5]), # 89 + case is_syscall: syscall_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, stack_b0, stack_b1]), # 104 + case is_call: call_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, stack_b0, stack_b1]), # 108 + }; + +} + +# NOOP operation: No operation - all stack elements remain unchanged +# Stack behavior: [a, b, c, ...] -> [a, b, c, ...] (no change) +ev noop_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # All positions unchanged + enf s0' = s0; + enf s1' = s1; + enf s2' = s2; + enf s3' = s3; + enf s4' = s4; + enf s5' = s5; + enf s6' = s6; + enf s7' = s7; + enf s8' = s8; + enf s9' = s9; + enf s10' = s10; + enf s11' = s11; + enf s12' = s12; + enf s13' = s13; + enf s14' = s14; + enf s15' = s15; +} + +# ADD operation: Add top two stack elements +# Stack behavior: [a, b, c, ...] -> [a+b, c, ...] (left shift - decreases depth by 1) +ev add_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets the computed sum + enf s0' = s0 + s1; + + # Positions 1-14: Left shift (each position gets value from position+1) + enf s1' = s2; + enf s2' = s3; + enf s3' = s4; + enf s4' = s5; + enf s5' = s6; + enf s6' = s7; + enf s7' = s8; + enf s8' = s9; + enf s9' = s10; + enf s10' = s11; + enf s11' = s12; + enf s12' = s13; + enf s13' = s14; + enf s14' = s15; + + # Position 15: Gets value from overflow table or 0 +} + +# HPERM operation: Apply RPO permutation to top 12 elements (high-degree operation) +# Stack layout: [R0(4), R1(4), C(4), ...] where R0=first rate word (top), R1=second rate word, C=capacity +# Internal sponge state order: [RATE0, RATE1, CAPACITY] - digest is in R0 (positions 0-3) after permutation +# Positions 0-11: Transformed by RPO permutation (validated by hash chiplet) +# Positions 12-15: Unchanged +ev hperm_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Positions 0-11: Transformed by RPO permutation (unconstrained, validated by hash chiplet) + # Request full state from hasher chiplet (SOUT returns all 12 elements) + bus_6_chiplets_bus.insert(HASHERRETURNSTATE, s0', s1', s2', s3', s4', s5', s6', s7', s8', s9', s10', s11') when 1; + + # Positions 12-15: Unchanged + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MPVERIFY operation: Verify Merkle path (high-degree operation) +# Stack behavior: [V0, V1, V2, V3, d, i, R0, R1, R2, R3, ...] -> [V0, V1, V2, V3, d, i, R0, R1, R2, R3, ...] +# Verifies Merkle path from node value V to root R at depth d and index i +ev mpverify_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Request Merkle path verification from hasher chiplet + # The hasher verifies that the path from leaf V (s0-s3) at index i (s5) and depth d (s4) + # results in root R (s6-s9). The result (should equal R) is returned in the response. + bus_6_chiplets_bus.insert(HASHERMPVERIFY, s6, s7, s8, s9) when 1; + + # Positions 0-9: Unchanged (node value, depth, index, root all stay on stack) + enf s0' = s0; enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; + enf s8' = s8; enf s9' = s9; + # Positions 10-15: Unchanged + enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# PIPE operation: Pop two words from advice stack, write to memory, replace rate portion of sponge (high-degree operation) +# Stack layout: [R0(4), R1(4), C(4), addr, ...] where R0, R1 are rate words, C is capacity +# After: [D0(4), D1(4), C(4), addr+8, ...] where D0, D1 are advice stack data +# Pops 8 elements from advice stack, writes to memory at address s12, places values on stack top +ev pipe_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Positions 0-7: Overwritten by advice stack values (unconstrained in stack module) + # Positions 8-11: Unchanged (capacity preserved) + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + # Position 12: Address incremented by 8 (2 words) + enf s12' = s12 + 8; + # Positions 13-15: Unchanged + enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MSTREAM operation: Load two words from memory, replace rate portion of sponge (high-degree operation) +# Stack layout: [R0(4), R1(4), C(4), addr, ...] where R0, R1 are rate words, C is capacity +# After: [M0(4), M1(4), C(4), addr+8, ...] where M0, M1 are memory values +# Loads 8 elements from memory starting at address s12, address incremented by 8 +ev mstream_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Positions 0-7: Overwritten by memory values (unconstrained) + # Positions 8-11: Unchanged (capacity preserved) + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + # Position 12: Address incremented by 8 + enf s12' = s12 + 8; + # Positions 13-15: Unchanged + enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# CRYPTOSTREAM operation: Read two words, add rate, write ciphertext, update rate. +# Stack layout: [R0(4), R1(4), C(4), src_ptr, dst_ptr, ...] +# After: [CT0(4), CT1(4), C(4), src_ptr+8, dst_ptr+8, ...] +ev cryptostream_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_ctx, system_clk]) { + # Positions 8-11: Unchanged (capacity preserved) + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + # Positions 12-13: Source/destination pointers incremented by 8 (2 words) + enf s12' = s12 + 8; + enf s13' = s13 + 8; + # Positions 14-15: Unchanged + enf s14' = s14; enf s15' = s15; + + # Plaintext = ciphertext - rate (element-wise) + let p0 = s0' - s0; let p1 = s1' - s1; let p2 = s2' - s2; let p3 = s3' - s3; + let p4 = s4' - s4; let p5 = s5' - s5; let p6 = s6' - s6; let p7 = s7' - s7; + + # Read two words from source and write two words to destination. + bus_6_chiplets_bus.insert(MEMREADWORD, system_ctx, s12, system_clk, p0, p1, p2, p3) when 1; + bus_6_chiplets_bus.insert(MEMREADWORD, system_ctx, s12 + 4, system_clk, p4, p5, p6, p7) when 1; + bus_6_chiplets_bus.insert(MEMWRITEWORD, system_ctx, s13, system_clk, s0', s1', s2', s3') when 1; + bus_6_chiplets_bus.insert(MEMWRITEWORD, system_ctx, s13 + 4, system_clk, s4', s5', s6', s7') when 1; +} + +# PUSH operation: Push an immediate value onto the stack (high-degree operation) +# Stack behavior: [a, b, c, ...] -> [imm, a, b, c, ...] (right shift - increases depth by 1) +# The immediate value is provided by the decoder and validated by the Op Group Table +# This evaluator only constrains the stack shift; s0' is unconstrained here +ev push_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets immediate value from decoder (unconstrained in stack module) + # The correctness of s0' is enforced by the Op Group Table, not here + + # Positions 1-15: Right shift (each position gets value from position-1) + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# MRUPDATE operation: Update Merkle tree node (very high-degree operation) +# Stack behavior: [V0, V1, V2, V3, d, i, R0, R1, R2, R3, NV0, NV1, NV2, NV3, ...] -> [NR0, NR1, NR2, NR3, d, i, R0, R1, R2, R3, NV0, NV1, NV2, NV3, ...] +# Updates node from old value V to new value NV, replaces top with new root NR +ev mrupdate_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Request Merkle root update from hasher chiplet + # This involves two verifications: + # 1. MV (old path): Verify path from old value V (s0-s3) results in old root R (s6-s9) + # 2. MU (new path): Verify path from new value NV (s10-s13) results in new root NR (s0'-s3') + # The hasher computes the new root and returns it. + bus_6_chiplets_bus.insert(HASHERMRUPDATEOLD, s6, s7, s8, s9) when 1; + bus_6_chiplets_bus.insert(HASHERMRUPDATENEW, s0', s1', s2', s3') when 1; + + # Positions 0-3: Overwritten by new root (unconstrained, validated by hash chiplet) + # Positions 4-15: Unchanged (depth, index, old root, new value all stay) + enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# HORNERBASE operation: Horner polynomial evaluation (high-degree operation) +# Stack layout: [c_0, c_1, c_2, c_3, c_4, c_5, c_6, c_7, -, -, -, -, -, alpha_ptr, acc0, acc1] +# where c_0 (at s0) is the highest-degree coefficient (α^7 term) and c_7 (at s7) is the constant term +# Helper registers: h0=α0, h1=α1, h2=tmp1_0, h3=tmp1_1, h4=tmp0_0, h5=tmp0_1 +# Extension field: 𝔽p[x]/(x² - 7), so x² = 7 +# Algorithm: +# tmp0 = acc·α² + c0·α + c1 (processes c0, c1) +# tmp1 = tmp0·α³ + c2·α² + c3·α + c4 (processes c2, c3, c4) +# acc' = tmp1·α³ + c5·α² + c6·α + c7 (processes c5, c6, c7) +ev hornerbase_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3, h4, h5]) { + # Positions 0-13: Unchanged + enf s0' = s0; enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; + + # Local variables for readability + let a0 = h0; + let a1 = h1; + let acc0 = s14; + let acc1 = s15; + let tmp0_0 = h4; + let tmp0_1 = h5; + let tmp1_0 = h2; + let tmp1_1 = h3; + + # For x² - 7: + # α² = (a0² + 7·a1², 2·a0·a1) + # α³ = (a0³ + 21·a0·a1², 3·a0²·a1 + 7·a1³) + # Multiplication (e0,e1)·(f0,f1) = (e0·f0 + 7·e1·f1, e0·f1 + e1·f0) + + # Constraint 1: tmp0_0 = acc·α² + c0·α + c1 (real part) | degree=3 + # tmp0_0 = acc0·(a0² + 7·a1²) + 7·acc1·(2·a0·a1) + s0·a0 + s1 + enf tmp0_0 = acc0 * a0^2 + 7 * acc0 * a1^2 + 14 * acc1 * a0 * a1 + + s0 * a0 + s1; + + # Constraint 2: tmp0_1 = acc·α² + c0·α (imag part) | degree=3 + # tmp0_1 = acc0·(2·a0·a1) + acc1·(a0² + 7·a1²) + s0·a1 + enf tmp0_1 = 2 * acc0 * a0 * a1 + acc1 * a0^2 + 7 * acc1 * a1^2 + + s0 * a1; + + # Constraint 3: tmp1_0 = tmp0·α³ + c2·α² + c3·α + c4 (real part) | degree=4 + # tmp1_0 = tmp0_0·(a0³ + 21·a0·a1²) + tmp0_1·(21·a0²·a1 + 49·a1³) + s2·(a0² + 7·a1²) + s3·a0 + s4 + enf tmp1_0 = tmp0_0 * (a0^3 + 21 * a0 * a1^2) + tmp0_1 * (21 * a0^2 * a1 + 49 * a1^3) + + s2 * a0^2 + 7 * s2 * a1^2 + s3 * a0 + s4; + + # Constraint 4: tmp1_1 = tmp0·α³ + c2·α² + c3·α (imag part) | degree=4 + # tmp1_1 = tmp0_0·(3·a0²·a1 + 7·a1³) + tmp0_1·(a0³ + 21·a0·a1²) + s2·(2·a0·a1) + s3·a1 + enf tmp1_1 = tmp0_0 * (3 * a0^2 * a1 + 7 * a1^3) + tmp0_1 * (a0^3 + 21 * a0 * a1^2) + + 2 * s2 * a0 * a1 + s3 * a1; + + # Constraint 5: acc'_0 = tmp1·α³ + c5·α² + c6·α + c7 (real part) | degree=4 + # acc'_0 = tmp1_0·(a0³ + 21·a0·a1²) + tmp1_1·(21·a0²·a1 + 49·a1³) + s5·(a0² + 7·a1²) + s6·a0 + s7 + enf s14' = tmp1_0 * (a0^3 + 21 * a0 * a1^2) + tmp1_1 * (21 * a0^2 * a1 + 49 * a1^3) + + s5 * a0^2 + 7 * s5 * a1^2 + s6 * a0 + s7; + + # Constraint 6: acc'_1 = tmp1·α³ + c5·α² + c6·α (imag part) | degree=4 + # acc'_1 = tmp1_0·(3·a0²·a1 + 7·a1³) + tmp1_1·(a0³ + 21·a0·a1²) + s5·(2·a0·a1) + s6·a1 + enf s15' = tmp1_0 * (3 * a0^2 * a1 + 7 * a1^3) + tmp1_1 * (a0^3 + 21 * a0 * a1^2) + + 2 * s5 * a0 * a1 + s6 * a1; +} + +# HORNEREXT operation: Horner polynomial evaluation with extension field coefficients (high-degree operation) +# Stack: [s0,s1: c_0, s2,s3: c_1, s4,s5: c_2, s6,s7: c_3, s8..s12: unused, s13: alpha_ptr, s14: acc0, s15: acc1] +# where each c_i is an extension field element (2 base field elements), c_0 (at s0,s1) is highest degree +# Helpers: h0=α0, h1=α1 (evaluation point), h2=k0, h3=k1, h4=tmp0, h5=tmp1 +# Extension field: 𝔽p[x]/(x² - 7), so x² = 7 +# Computes: tmp = c1 + c0·α + acc·α², then acc' = c3 + c2·α + tmp·α² +ev hornerext_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3, h4, h5]) { + # Positions 0-13: Unchanged + enf s0' = s0; enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; + + # Local variables for readability + let a0 = h0; + let a1 = h1; + let acc0 = s14; + let acc1 = s15; + let tmp0 = h4; + let tmp1 = h5; + + # For x² - 7: α² = (a0² + 7·a1², 2·a0·a1) + # Multiplication (e0,e1)·(f0,f1) = (e0·f0 + 7·e1·f1, e0·f1 + e1·f0) + + # Constraint 1: tmp0 = acc0·(a0² + 7·a1²) + 7·acc1·(2·a0·a1) + s0·a0 + 7·s1·a1 + s2 | degree=3 + enf tmp0 = acc0 * a0^2 + 7 * acc0 * a1^2 + 14 * acc1 * a0 * a1 + + s0 * a0 + 7 * s1 * a1 + + s2; + + # Constraint 2: tmp1 = acc1·(a0² + 7·a1²) + acc0·(2·a0·a1) + s1·a0 + s0·a1 + s3 | degree=3 + enf tmp1 = acc1 * a0^2 + 7 * acc1 * a1^2 + 2 * acc0 * a0 * a1 + + s1 * a0 + s0 * a1 + + s3; + + # Constraint 3: acc0' = tmp0·(a0² + 7·a1²) + 7·tmp1·(2·a0·a1) + s4·a0 + 7·s5·a1 + s6 | degree=3 + enf s14' = tmp0 * a0^2 + 7 * tmp0 * a1^2 + 14 * tmp1 * a0 * a1 + + s4 * a0 + 7 * s5 * a1 + + s6; + + # Constraint 4: acc1' = tmp1·(a0² + 7·a1²) + tmp0·(2·a0·a1) + s5·a0 + s4·a1 + s7 | degree=3 + enf s15' = tmp1 * a0^2 + 7 * tmp1 * a1^2 + 2 * tmp0 * a0 * a1 + + s5 * a0 + s4 * a1 + + s7; +} + +# EVALCIRCUIT operation: Evaluate arithmetic circuit (high-degree operation) +# Stack: [ptr: circuit pointer, nread: read count, neval: eval count, ...] - all unchanged +# Evaluates arithmetic circuit using ACE chiplet, asserts result equals zero +ev evalcircuit_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # All positions unchanged (circuit evaluation handled by ACE chiplet) + enf s0' = s0; enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# LOG_PRECOMPILE operation: Apply Poseidon2 to [COMM, TAG, CAP_PREV] and update stack. +# Stack behavior: [COMM, TAG, PAD, ...] -> [R0, R1, CAP_NEXT, ...] +ev logprecompile_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3, h4]) { + # Positions 0-11: overwritten by hasher outputs (unconstrained in stack module) + # Positions 12-15: unchanged + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; + + # CAP_PREV comes from decoder helper registers h1..h4; CAP_NEXT is s8'..s11'. + bus_5_v_table.remove(LOGPRECOMPILE, h1, h2, h3, h4) when 1; + bus_5_v_table.insert(LOGPRECOMPILE, s8', s9', s10', s11') when 1; + + # Link the output state to the hasher chiplet bus. + bus_6_chiplets_bus.insert(HASHERRETURNSTATE, s0', s1', s2', s3', s4', s5', s6', s7', s8', s9', s10', s11') when 1; +} + +# DUP operation: Duplicate top stack element +# Stack behavior: [a, b, c, ...] -> [a, a, b, c, ...] (right shift - increases depth by 1) +ev dup_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets duplicated value (stays same) + enf s0' = s0; + + # Positions 1-15: Right shift (each position gets value from position-1) + enf s1' = s0; # Original s0 shifts down to s1 + enf s2' = s1; # s1 shifts down to s2 + enf s3' = s2; # s2 shifts down to s3 + enf s4' = s3; # s3 shifts down to s4 + enf s5' = s4; # s4 shifts down to s5 + enf s6' = s5; # s5 shifts down to s6 + enf s7' = s6; # s6 shifts down to s7 + enf s8' = s7; # s7 shifts down to s8 + enf s9' = s8; # s8 shifts down to s9 + enf s10' = s9; # s9 shifts down to s10 + enf s11' = s10; # s10 shifts down to s11 + enf s12' = s11; # s11 shifts down to s12 + enf s13' = s12; # s12 shifts down to s13 + enf s14' = s13; # s13 shifts down to s14 + enf s15' = s14; # s14 shifts down to s15 + # Original s15 is pushed to overflow table (handled by other constraints) +} + +# SWAP operation: Exchange top two stack elements +# Stack behavior: [a, b, c, ...] -> [b, a, c, ...] (no stack shift) +ev swap_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Positions 0,1: Swapped + enf s0' = s1; # s1 moves to top + enf s1' = s0; # s0 moves to second + + # Positions 2-15: Unchanged + enf s2' = s2; + enf s3' = s3; + enf s4' = s4; + enf s5' = s5; + enf s6' = s6; + enf s7' = s7; + enf s8' = s8; + enf s9' = s9; + enf s10' = s10; + enf s11' = s11; + enf s12' = s12; + enf s13' = s13; + enf s14' = s14; + enf s15' = s15; +} + +# DROP operation: Remove top stack element +# Stack behavior: [a, b, c, ...] -> [b, c, ...] (left shift - decreases depth by 1) +ev drop_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # All positions shift up (left shift) + enf s0' = s1; # s1 moves to top + enf s1' = s2; # s2 moves to second + enf s2' = s3; # s3 moves to third + enf s3' = s4; # s4 moves to fourth + enf s4' = s5; # s5 moves to fifth + enf s5' = s6; # s6 moves to sixth + enf s6' = s7; # s7 moves to seventh + enf s7' = s8; # s8 moves to eighth + enf s8' = s9; # s9 moves to ninth + enf s9' = s10; # s10 moves to tenth + enf s10' = s11; # s11 moves to eleventh + enf s11' = s12; # s12 moves to twelfth + enf s12' = s13; # s13 moves to thirteenth + enf s13' = s14; # s14 moves to fourteenth + enf s14' = s15; # s15 moves to fifteenth + # s15' comes from overflow table or is 0 (handled by left_shift_zero_insertion) +} + +# PAD operation: Push 0 onto the stack +# Stack behavior: [a, b, c, ...] -> [0, a, b, c, ...] (right shift - increases depth by 1) +ev pad_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets 0 + enf s0' = 0; + + # Positions 1-15: Right shift (each position gets value from position-1) + enf s1' = s0; # s0 shifts down to s1 + enf s2' = s1; # s1 shifts down to s2 + enf s3' = s2; # s2 shifts down to s3 + enf s4' = s3; # s3 shifts down to s4 + enf s5' = s4; # s4 shifts down to s5 + enf s6' = s5; # s5 shifts down to s6 + enf s7' = s6; # s6 shifts down to s7 + enf s8' = s7; # s7 shifts down to s8 + enf s9' = s8; # s8 shifts down to s9 + enf s10' = s9; # s9 shifts down to s10 + enf s11' = s10; # s10 shifts down to s11 + enf s12' = s11; # s11 shifts down to s12 + enf s13' = s12; # s12 shifts down to s13 + enf s14' = s13; # s13 shifts down to s14 + enf s15' = s14; # s14 shifts down to s15 + # Original s15 is pushed to overflow table (handled by other constraints) +} + +# MUL operation: Multiply top two stack elements +# Stack behavior: [a, b, c, ...] -> [a*b, c, ...] (left shift - decreases depth by 1) +ev mul_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets the computed product + enf s0' = s0 * s1; + + # Positions 1-14: Left shift (each position gets value from position+1) + enf s1' = s2; + enf s2' = s3; + enf s3' = s4; + enf s4' = s5; + enf s5' = s6; + enf s6' = s7; + enf s7' = s8; + enf s8' = s9; + enf s9' = s10; + enf s10' = s11; + enf s11' = s12; + enf s12' = s13; + enf s13' = s14; + enf s14' = s15; + + # Position 15: Gets value from overflow table or 0 + # (handled by left_shift_zero_insertion constraint) +} + +# ASSERT operation: Remove top stack element and assert it equals 1 +# Stack behavior: [a, b, c, ...] -> [b, c, ...] (left shift - decreases depth by 1, requires a = 1) +ev assert_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Assert that the top element equals 1 + enf s0 = 1; + + # All positions shift up (left shift) - same as DROP + enf s0' = s1; # s1 moves to top + enf s1' = s2; # s2 moves to second + enf s2' = s3; # s3 moves to third + enf s3' = s4; # s4 moves to fourth + enf s4' = s5; # s5 moves to fifth + enf s5' = s6; # s6 moves to sixth + enf s6' = s7; # s7 moves to seventh + enf s7' = s8; # s8 moves to eighth + enf s8' = s9; # s9 moves to ninth + enf s9' = s10; # s10 moves to tenth + enf s10' = s11; # s11 moves to eleventh + enf s11' = s12; # s12 moves to twelfth + enf s12' = s13; # s13 moves to thirteenth + enf s13' = s14; # s14 moves to fourteenth + enf s14' = s15; # s15 moves to fifteenth + # s15' comes from overflow table or is 0 (handled by left_shift_zero_insertion) +} + +# EQ operation: Compare top two stack elements for equality +# Stack behavior: [a, b, c, ...] -> [(a == b ? 1 : 0), c, ...] (left shift - decreases depth by 1) +ev eq_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0]) { + # Position 0: Gets comparison result (1 if s0 == s1, 0 otherwise) + let diff = s0 - s1; + enf diff * s0' = 0; + enf s0' = (1 - diff * h0); + + # Positions 1-14: Left shift (each position gets value from position+1) + enf s1' = s2; + enf s2' = s3; + enf s3' = s4; + enf s4' = s5; + enf s5' = s6; + enf s6' = s7; + enf s7' = s8; + enf s8' = s9; + enf s9' = s10; + enf s10' = s11; + enf s11' = s12; + enf s12' = s13; + enf s13' = s14; + enf s14' = s15; + + # Position 15: Gets value from overflow table or 0 + # (handled by left_shift_zero_insertion constraint) +} + +# DUP1 operation: Duplicate element at position 1 to the top +# Stack behavior: [a, b, c, ...] -> [b, a, b, c, ...] (right shift - increases depth by 1) +ev dup1_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s1 (element from position 1 is duplicated to top) + enf s0' = s1; + + # Positions 1-15: Right shift (each position gets value from position-1) + enf s1' = s0; # s0 shifts down to s1 + enf s2' = s1; # s1 shifts down to s2 (but s1 is also copied to top) + enf s3' = s2; # s2 shifts down to s3 + enf s4' = s3; # s3 shifts down to s4 + enf s5' = s4; # s4 shifts down to s5 + enf s6' = s5; # s5 shifts down to s6 + enf s7' = s6; # s6 shifts down to s7 + enf s8' = s7; # s7 shifts down to s8 + enf s9' = s8; # s8 shifts down to s9 + enf s10' = s9; # s9 shifts down to s10 + enf s11' = s10; # s10 shifts down to s11 + enf s12' = s11; # s11 shifts down to s12 + enf s13' = s12; # s12 shifts down to s13 + enf s14' = s13; # s13 shifts down to s14 + enf s15' = s14; # s14 shifts down to s15 + # Original s15 is pushed to overflow table (handled by other constraints) +} + +# DUP2 operation: Duplicate element at position 2 to the top +# Stack behavior: [a, b, c, d, ...] -> [c, a, b, c, d, ...] (right shift - increases depth by 1) +ev dup2_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s2 (element from position 2 is duplicated to top) + enf s0' = s2; + + # Positions 1-15: Right shift (each position gets value from position-1) + enf s1' = s0; # s0 shifts down to s1 + enf s2' = s1; # s1 shifts down to s2 + enf s3' = s2; # s2 shifts down to s3 (but s2 is also copied to top) + enf s4' = s3; # s3 shifts down to s4 + enf s5' = s4; # s4 shifts down to s5 + enf s6' = s5; # s5 shifts down to s6 + enf s7' = s6; # s6 shifts down to s7 + enf s8' = s7; # s7 shifts down to s8 + enf s9' = s8; # s8 shifts down to s9 + enf s10' = s9; # s9 shifts down to s10 + enf s11' = s10; # s10 shifts down to s11 + enf s12' = s11; # s11 shifts down to s12 + enf s13' = s12; # s12 shifts down to s13 + enf s14' = s13; # s13 shifts down to s14 + enf s15' = s14; # s14 shifts down to s15 + # Original s15 is pushed to overflow table (handled by other constraints) +} + +# DUP3 operation: Duplicate element at position 3 to the top +# Stack behavior: [a, b, c, d, e, ...] -> [d, a, b, c, d, e, ...] (right shift - increases depth by 1) +ev dup3_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s3 (element from position 3 is duplicated to top) + enf s0' = s3; + + # Positions 1-15: Right shift (each position gets value from position-1) + enf s1' = s0; # s0 shifts down to s1 + enf s2' = s1; # s1 shifts down to s2 + enf s3' = s2; # s2 shifts down to s3 + enf s4' = s3; # s3 shifts down to s4 (but s3 is also copied to top) + enf s5' = s4; # s4 shifts down to s5 + enf s6' = s5; # s5 shifts down to s6 + enf s7' = s6; # s6 shifts down to s7 + enf s8' = s7; # s7 shifts down to s8 + enf s9' = s8; # s8 shifts down to s9 + enf s10' = s9; # s9 shifts down to s10 + enf s11' = s10; # s10 shifts down to s11 + enf s12' = s11; # s11 shifts down to s12 + enf s13' = s12; # s12 shifts down to s13 + enf s14' = s13; # s13 shifts down to s14 + enf s15' = s14; # s14 shifts down to s15 + # Original s15 is pushed to overflow table (handled by other constraints) +} + +# DUP4 operation: Duplicate element at position 4 to the top +ev dup4_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + enf s0' = s4; + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# DUP5 operation: Duplicate element at position 5 to the top +ev dup5_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + enf s0' = s5; + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# DUP6 operation: Duplicate element at position 6 to the top +ev dup6_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + enf s0' = s6; + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# DUP7 operation: Duplicate element at position 7 to the top +ev dup7_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + enf s0' = s7; + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# DUP9 operation: Duplicate element at position 9 to the top +ev dup9_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + enf s0' = s9; + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# DUP11 operation: Duplicate element at position 11 to the top +ev dup11_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + enf s0' = s11; + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# DUP13 operation: Duplicate element at position 13 to the top +ev dup13_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + enf s0' = s13; + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# DUP15 operation: Duplicate element at position 15 to the top +ev dup15_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + enf s0' = s15; + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# ADVPOP operation: Pop value from advice stack and push to operand stack top +ev advpop_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets value from advice stack (unconstrained - comes from external input) + # Positions 1-15: Right shift (each position gets value from position-1) + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# SDEPTH operation: Push current stack depth to the top +ev sdepth_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, stack_depth]) { + # SDEPTH: Push current stack depth to stack (right shift) + # s0' gets current stack depth (b0), all other elements shift right + enf s0' = stack_depth; + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# CLK operation: Push current clock cycle to the top +ev clk_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, clk]) { + # Position 0: Gets current clock cycle (properly constrained) + enf s0' = clk; + + # Positions 1-15: Right shift (each position gets value from position-1) + enf s1' = s0; enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; + enf s9' = s8; enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +########################################################################################## +# LEFT STACK SHIFT OPERATION CONSTRAINTS +########################################################################################## + +# AND operation: Bitwise AND of two field elements +# Stack behavior: [a, b, c, ...] -> [a & b, c, ...] (left shift - decreases depth by 1) +ev and_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets bitwise AND result + # Constraint: s0' = s0 & s1 (bitwise AND in field arithmetic is multiplication) + enf s0' = binary_and(s0, s1); + + # Positions 1-14: Left shift (each position gets value from position+1) + enf s1' = s2; enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; enf s8' = s9; + enf s9' = s10; enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + # s15' comes from overflow table or is 0 (handled by left_shift_zero_insertion) +} + +# OR operation: Bitwise OR of two field elements +# Stack behavior: [a, b, c, ...] -> [a | b, c, ...] (left shift - decreases depth by 1) +ev or_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets bitwise OR Result + # Constraint: s0 and s1 must be boolean (0 or 1), and s0' = s0 | s1 + enf is_binary([s0]); + enf is_binary([s1]); + enf s0' = binary_or(s0, s1); + + # Positions 1-14: Left shift (each position gets value from position+1) + enf s1' = s2; enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; enf s8' = s9; + enf s9' = s10; enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + # s15' comes from overflow table or is 0 (handled by left_shift_zero_insertion) +} + +# CSWAP operation: Conditional swap based on top element +# Stack behavior: [c, a, b, ...] -> [a_or_b, b_or_a, ...] where swap occurs if c != 0 (left shift - decreases depth by 1) +# If c = 0: [c, a, b, ...] -> [a, b, ...] (no swap) +# If c = 1: [c, a, b, ...] -> [b, a, ...] (swap) +ev cswap_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Control bit (s0) must be binary (0 or 1) + # Constraint: s0^2 - s0 = 0, which is s0 * (s0 - 1) = 0 (degree 2) + enf s0 * (s0 - 1) = 0; + + # Position 0: Conditional swap for first element + # Constraint: s0' - s0 * s2 - (1 - s0) * s1 = 0 (degree 2) + # - If s0 = 0: s0' = 0 * s2 + 1 * s1 = s1 (no swap, keep s1) + # - If s0 = 1: s0' = 1 * s2 + 0 * s1 = s2 (swap, take s2) + enf s0' = s0 * s2 + (1 - s0) * s1; + + # Position 1: Conditional swap for second element + # Constraint: s1' - s0 * s1 - (1 - s0) * s2 = 0 (degree 2) + # - If s0 = 0: s1' = 0 * s1 + 1 * s2 = s2 (no swap, keep s2) + # - If s0 = 1: s1' = 1 * s1 + 0 * s2 = s1 (swap, take s1) + enf s1' = s0 * s1 + (1 - s0) * s2; + + # Positions 2-14: Left shift (each position gets value from position+1) + enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; enf s8' = s9; + enf s9' = s10; enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + # s15' comes from overflow table or is 0 (handled by left_shift_zero_insertion) +} + +# CSWAPW operation: Conditional word swap based on top element (left shift - decreases depth by 1) +# Swaps two 4-element words (A and B) based on control bit, then pops the control bit +# +# Stack layout (current frame): +# s0 = c (control bit) +# s1-s4 = A (word A: [a0, a1, a2, a3]) +# s5-s8 = B (word B: [b0, b1, b2, b3]) +# +# Stack behavior: +# If c = 0 (no swap): [c, a0, a1, a2, a3, b0, b1, b2, b3, ...] -> [a0, a1, a2, a3, b0, b1, b2, b3, ...] +# If c = 1 (swap): [c, a0, a1, a2, a3, b0, b1, b2, b3, ...] -> [b0, b1, b2, b3, a0, a1, a2, a3, ...] +# +# The operation uses three types of constraints: +# 1. Binary constraint ensuring c ∈ {0, 1} +# 2. Conditional multiplexer for first word: selects between A (if c=0) or B (if c=1) +# 3. Conditional multiplexer for second word: selects between B (if c=0) or A (if c=1) +ev cswapw_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Binary constraint: Control element must be 0 or 1 + # Constraint: s0^2 - s0 = 0, equivalently s0 * (s0 - 1) = 0 (degree 2) + # This ensures s0 ∈ {0, 1} + enf s0 * (s0 - 1) = 0; + + # First word output (positions 0-3 in next frame): Conditional multiplexer + # For i ∈ [0, 4): Constraint s_i' = s0 * s_(i+5) + (1 - s0) * s_(i+1) (degree 2) + # This implements: s_i' = c ? B[i] : A[i] + # + # Position 0: s0' = s0 * s5 + (1 - s0) * s1 + # If c = 0: s0' = 0 * b0 + 1 * a0 = a0 (output first element of A) + # If c = 1: s0' = 1 * b0 + 0 * a0 = b0 (output first element of B) + enf s0' = s0 * s5 + (1 - s0) * s1; + enf s1' = s0 * s6 + (1 - s0) * s2; + enf s2' = s0 * s7 + (1 - s0) * s3; + enf s3' = s0 * s8 + (1 - s0) * s4; + + # Second word output (positions 4-7 in next frame): Conditional multiplexer + # For i ∈ [0, 4): Constraint s_(i+4)' = s0 * s_(i+1) + (1 - s0) * s_(i+5) (degree 2) + # This implements: s_(i+4)' = c ? A[i] : B[i] + # + # Position 4: s4' = s0 * s1 + (1 - s0) * s5 + # If c = 0: s4' = 0 * a0 + 1 * b0 = b0 (output first element of B) + # If c = 1: s4' = 1 * a0 + 0 * b0 = a0 (output first element of A) + enf s4' = s0 * s1 + (1 - s0) * s5; + enf s5' = s0 * s2 + (1 - s0) * s6; + enf s6' = s0 * s3 + (1 - s0) * s7; + enf s7' = s0 * s4 + (1 - s0) * s8; + + # Positions 8-14: Left shift (each position gets value from position+1) + enf s8' = s9; enf s9' = s10; enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + # s15' comes from overflow table or is 0 (handled by left_shift_zero_insertion) +} + +# U32SPLIT operation: Split element into u32 low and high parts +# Stack: [a, ...] -> [lo, hi, ...] where lo is on top (right shift - increases depth by 1) +# Helpers: h0=limb0, h1=limb1, h2=limb2, h3=limb3 (16-bit limbs), h4=m (validity check) +ev u32split_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3, h4]) { + # Local variables for 16-bit limbs + let limb0 = h0; + let limb1 = h1; + let limb2 = h2; + let limb3 = h3; + let m = h4; + + # Constraint 1: Original value reconstruction s0 = 2^48·h3 + 2^32·h2 + 2^16·h1 + h0 + enf s0 = limb3 * 2^48 + limb2 * 2^32 + limb1 * 2^16 + limb0; + + # Constraint 2: Lower 32 bits s0' = 2^16·h1 + h0 (lo on top - LE convention) + let v_lo = limb1 * 2^16 + limb0; + enf s0' = v_lo; + + # Constraint 3: Upper 32 bits s1' = 2^16·h3 + h2 (hi below) + let v_hi = limb3 * 2^16 + limb2; + enf s1' = v_hi; + + # Constraint 4: Element validity check (1 - m·(2^32 - 1 - v_hi))·v_lo = 0 | degree=3 + enf (1 - m * (2^32 - 1 - v_hi)) * v_lo = 0; + + # Positions 2-15: Right shift + enf s2' = s1; enf s3' = s2; enf s4' = s3; enf s5' = s4; enf s6' = s5; enf s7' = s6; enf s8' = s7; enf s9' = s8; + enf s10' = s9; enf s11' = s10; enf s12' = s11; enf s13' = s12; enf s14' = s13; enf s15' = s14; +} + +# U32ASSERT2 operation: Assert that two stack values are valid u32 values (< 2^32) +# Stack behavior: [b, a, ...] -> [b, a, ...] (unchanged - this is an assertion operation) +# Helper registers: h0-h1 contain 16-bit limbs of a, h2-h3 contain 16-bit limbs of b +ev u32assert2_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3]) { + # Local variables for 16-bit limbs + let limb0_a = h0; # Low limb of a + let limb1_a = h1; # High limb of a + let limb0_b = h2; # Low limb of b + let limb1_b = h3; # High limb of b + + # Constraint 1: Verify b (at s0) can be represented as two 16-bit limbs + enf s0' = limb1_b * 2^16 + limb0_b; + + # Constraint 2: Verify a (at s1) can be represented as two 16-bit limbs + enf s1' = limb1_a * 2^16 + limb0_a; + + # Positions 2-15: Unchanged + enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; + enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# U32ADD operation: Addition of two u32 values +# Stack behavior: [a, b, ...] -> [sum, carry, ...] where sum is on top (LE convention) +# Helper registers: h0-h2 contain 16-bit limbs of sum, h3 is set to 0 +ev u32add_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3]) { + # Local variables for 16-bit limbs + let limb0 = h0; # Low 16-bit limb of sum + let limb1 = h1; # Mid 16-bit limb of sum + let limb2 = h2; # High limb (carry bit) + + # Constraint 1: Sum reconstruction s0 + s1 = 2^32·h2 + 2^16·h1 + h0 + enf s0 + s1 = limb2 * 2^32 + limb1 * 2^16 + limb0; + + # Constraint 2: Lower 32 bits s0' = 2^16·h1 + h0 (sum on top - LE convention) + enf s0' = limb1 * 2^16 + limb0; + + # Constraint 3: Carry bit s1' = h2 (0 or 1) (carry below) + enf s1' = limb2; + + # Positions 2-15: Unchanged + enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; + enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# U32SUB operation: Subtraction of two u32 values +# Stack behavior: [b, a, ...] -> [d, c, ...] where c = (a - b) mod 2^32, d = borrow bit (0 or 1) +# Helper registers: h0-h1 contain 16-bit limbs of difference, h2-h3 are set to 0 +ev u32sub_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3]) { + # Local variables for 16-bit limbs + let limb0 = h0; # Low 16-bit limb of difference + let limb1 = h1; # High 16-bit limb of difference + + # Constraint 1: Subtraction relationship s1 = s0 + s1' + 2^32·s0' (i.e., a = b + c + 2^32·d) + enf s1 - s0 = s1' + s0' * 2^32; + + # Constraint 2: Borrow bit is binary s0'^2 - s0' = 0 + enf is_binary([s0']); + + # Constraint 3: Result s1' = 2^16·h1 + h0 + enf s1' = limb1 * 2^16 + limb0; + + # Positions 2-15: Unchanged + enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; + enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# U32DIV operation: Division of two u32 values +# Stack behavior: [b, a, ...] -> [d, c, ...] where c = a / b (quotient), d = a mod b (remainder) +# Helper registers: h0-h1 contain 16-bit limbs of (a - c), h2-h3 contain 16-bit limbs of (b - d - 1) +ev u32div_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3]) { + # Constraint 1: Division relationship s1 = s0·s1' + s0' (i.e., a = b·c + d) | degree=2 + enf s1 = s0 * s1' + s0'; + + # Constraint 2: Quotient bound s1 - s1' = 2^16·h1 + h0 (ensures c ≤ a) + enf s1 - s1' = h1 * 2^16 + h0; + + # Constraint 3: Remainder bound s0 - s0' - 1 = 2^16·h3 + h2 (ensures d < b) + enf s0 - s0' - 1 = h3 * 2^16 + h2; + + # Positions 2-15: Unchanged + enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; + enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# U32ADD3 operation: Addition of three u32 values +# Stack behavior: [a, b, c, ...] -> [sum, carry, ...] where sum is on top (LE convention) +# Helper registers: h0-h2 contain 16-bit limbs of sum, h3 is set to 0 +ev u32add3_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3]) { + # Local variables for 16-bit limbs + let limb0 = h0; # Low 16-bit limb of sum + let limb1 = h1; # Mid 16-bit limb of sum + let limb2 = h2; # High limb (can be 0, 1, or 2) + + # Constraint 1: Sum reconstruction s0 + s1 + s2 = 2^32·h2 + 2^16·h1 + h0 + enf s0 + s1 + s2 = limb2 * 2^32 + limb1 * 2^16 + limb0; + + # Constraint 2: Lower 32 bits s0' = 2^16·h1 + h0 (sum on top - LE convention) + enf s0' = limb1 * 2^16 + limb0; + + # Constraint 3: Carry s1' = h2 (can be 0, 1, or 2) (carry below) + enf s1' = limb2; + + # Positions 2-14: Left shift (position 2 consumed) + enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; enf s8' = s9; enf s9' = s10; + enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; +} + +# U32MUL operation: Multiplication of two u32 values +# Stack behavior: [a, b, ...] -> [lo, hi, ...] where lo is on top (LE convention) +# Helper registers: h0-h3 contain 16-bit limbs of product, h4 contains m for validity check +ev u32mul_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3, h4]) { + # Local variables for 16-bit limbs + let limb0 = h0; + let limb1 = h1; + let limb2 = h2; + let limb3 = h3; + let m = h4; + + # Constraint 1: Product reconstruction s0 * s1 = 2^48·h3 + 2^32·h2 + 2^16·h1 + h0 | degree=2 + enf s0 * s1 = limb3 * 2^48 + limb2 * 2^32 + limb1 * 2^16 + limb0; + + # Constraint 2: Lower 32 bits s0' = 2^16·h1 + h0 (lo on top - LE convention) + let v_lo = limb1 * 2^16 + limb0; + enf s0' = v_lo; + + # Constraint 3: Upper 32 bits s1' = 2^16·h3 + h2 (hi below) + let v_hi = limb3 * 2^16 + limb2; + enf s1' = v_hi; + + # Constraint 4: Element validity check (1 - m·(2^32 - 1 - v_hi))·v_lo = 0 | degree=3 + enf (1 - m * (2^32 - 1 - v_hi)) * v_lo = 0; + + # Positions 2-15: Unchanged + enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; + enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# U32MADD operation: Multiply-add of three u32 values (a * b + c) +# Stack behavior: [a, b, c, ...] -> [lo, hi, ...] where lo is on top (LE convention) +# Helper registers: h0-h3 contain 16-bit limbs of result, h4 contains m for validity check +ev u32madd_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3, h4]) { + # Local variables for 16-bit limbs + let limb0 = h0; + let limb1 = h1; + let limb2 = h2; + let limb3 = h3; + let m = h4; + + # Constraint 1: Multiply-add reconstruction s0 * s1 + s2 = 2^48·h3 + 2^32·h2 + 2^16·h1 + h0 | degree=2 + enf s0 * s1 + s2 = limb3 * 2^48 + limb2 * 2^32 + limb1 * 2^16 + limb0; + + # Constraint 2: Lower 32 bits s0' = 2^16·h1 + h0 (lo on top - LE convention) + let v_lo = limb1 * 2^16 + limb0; + enf s0' = v_lo; + + # Constraint 3: Upper 32 bits s1' = 2^16·h3 + h2 (hi below) + let v_hi = limb3 * 2^16 + limb2; + enf s1' = v_hi; + + # Constraint 4: Element validity check (1 - m·(2^32 - 1 - v_hi))·v_lo = 0 | degree=3 + enf (1 - m * (2^32 - 1 - v_hi)) * v_lo = 0; + + # Positions 2-14: Left shift (position 2 consumed in operation) + enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; enf s8' = s9; enf s9' = s10; + enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; +} + +# U32AND operation: Bitwise AND of two u32 values +# Stack behavior: [a, b, c, ...] -> [a & b, c, ...] where a,b are u32 values (left shift - decreases depth by 1) +ev u32and_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets u32 bitwise AND result from Bitwise chiplet (unconstrained in stack module) + # Positions 1-14: Left shift (each position gets value from position+1) + enf s1' = s2; enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; enf s8' = s9; + enf s9' = s10; enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + # s15' comes from overflow table or is 0 (handled by left_shift_zero_insertion) + + # Insert bitwise AND request to chiplets bus + # Operands: s0 (top of stack), s1 (second element) + # Result: s0' (will contain the AND result) + bus_6_chiplets_bus.insert(BITWISEAND, s0, s1, s0') when 1; +} + +# U32XOR operation: Bitwise XOR of two u32 values +# Stack behavior: [a, b, c, ...] -> [a ^ b, c, ...] where a,b are u32 values (left shift - decreases depth by 1) +ev u32xor_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets u32 bitwise XOR result from Bitwise chiplet (unconstrained in stack module) + # Positions 1-14: Left shift (each position gets value from position+1) + enf s1' = s2; enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; enf s8' = s9; + enf s9' = s10; enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + # s15' comes from overflow table or is 0 (handled by left_shift_zero_insertion) + + # Insert bitwise XOR request to chiplets bus + # Operands: s0 (top of stack), s1 (second element) + # Result: s0' (will contain the XOR result) + bus_6_chiplets_bus.insert(BITWISEXOR, s0, s1, s0') when 1; +} + +# MLOADW operation: Load word from memory at address s4 +# Stack behavior: [a, b, c, d, addr, ...] -> [v3, v2, v1, v0, ...] +ev mloadw_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_ctx, system_clk]) { + # Positions 0-3: Overwritten by memory word (unconstrained) + # Positions 4-14: Left shift + enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; enf s8' = s9; enf s9' = s10; + enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + + # Insert memory read word request to chiplets bus + # MLOADW reads a 4-element word from memory address s0 (must be word-aligned) + # The word will be placed in s0', s1', s2', s3' (unconstrained here, but constrained by memory chiplet response) + bus_6_chiplets_bus.insert(MEMREADWORD, system_ctx, s0, system_clk, s0', s1', s2', s3') when 1; +} + +# MSTORE operation: Store element to memory at address s0 +# Stack behavior: [addr, value, ...] -> [value, ...] +ev mstore_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_ctx, system_clk]) { + # Positions 0-14: Left shift by 1 (address consumed, value stays) + enf s0' = s1; enf s1' = s2; enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; + enf s6' = s7; enf s7' = s8; enf s8' = s9; enf s9' = s10; enf s10' = s11; enf s11' = s12; + enf s12' = s13; enf s13' = s14; enf s14' = s15; + + # Insert memory write element request to chiplets bus + # MSTORE writes a single element (s1) to memory address s0 in the current execution context + bus_6_chiplets_bus.insert(MEMWRITEELEMENT, system_ctx, s0, system_clk, s1) when 1; +} + +# MSTOREW operation: Store word to memory at address s0 +# Stack behavior: [addr, v0, v1, v2, v3, ...] -> [v0, v1, v2, v3, ...] +ev mstorew_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_ctx, system_clk]) { + # Positions 0-14: Left shift by 1 (address consumed, word stays) + enf s0' = s1; enf s1' = s2; enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; + enf s6' = s7; enf s7' = s8; enf s8' = s9; enf s9' = s10; enf s10' = s11; enf s11' = s12; + enf s12' = s13; enf s13' = s14; enf s14' = s15; + + # Insert memory write word request to chiplets bus + # MSTOREW writes a 4-element word (s1, s2, s3, s4) to memory address s0 (must be word-aligned) + bus_6_chiplets_bus.insert(MEMWRITEWORD, system_ctx, s0, system_clk, s1, s2, s3, s4) when 1; +} + +# FRIE2F4 operation: FRI layer folding with factor 4 in degree-2 extension field +# Performs FRI layer folding by factor 4, verifies previous layer correctness, and prepares +# state for next FRI layer. All constraints are degree ≤ 2. +# +# Input stack: [v7, v6, v5, v4, v3, v2, v1, v0, f_pos, d_seg, poe, pe1, pe0, a1, a0, cptr, ...] +# Output stack: [tmp0_1, tmp0_0, tmp1_1, tmp1_0, df3, df2, df1, df0, poe², tau_factor, cptr+8, poe⁴, f_pos, ne1, ne0, eptr, ...] +# +# Where: +# v0-v7: Four query points (q₀, q₁, q₂, q₃) in extension field +# a0, a1: Verifier challenge α +# poe: Power of domain generator +# d_seg: Domain segment (0, 1, 2, or 3) +# pe0, pe1: Previous layer result +# ne0, ne1: New folded result +# df0-df3: One-hot encoding flags for d_seg +# tmp0, tmp1: Intermediate fold results +ev frie2f4_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0, h1, h2, h3, h4, h5]) { + #################################################################################### + # CONSTANTS + #################################################################################### + + let DOMAIN_OFFSET = 7; + let TAU_INV = 18446462594437873665; # τ⁻¹ (4th root of unity inverse) + let TAU_INV2 = 18446744069414584320; # τ⁻² + let TAU_INV3 = 281474976710656; # τ⁻³ + + #################################################################################### + # INPUT STACK POSITIONS + #################################################################################### + + # Query points (4 extension field elements) + let v7 = s0; # q₃.1 + let v6 = s1; # q₃.0 + let v5 = s2; # q₂.1 + let v4 = s3; # q₂.0 + let v3 = s4; # q₁.1 + let v2 = s5; # q₁.0 + let v1 = s6; # q₀.1 + let v0 = s7; # q₀.0 + + # Challenge and state + let f_pos = s8; # Folded position + let d_seg = s9; # Domain segment (0-3) + let poe = s10; # Power of domain generator + let pe1 = s11; # Previous layer result, coefficient 1 + let pe0 = s12; # Previous layer result, coefficient 0 + let alpha_1 = s13; # α.1 + let alpha_0 = s14; # α.0 + let cptr = s15; # Current layer pointer + + #################################################################################### + # OUTPUT STACK POSITIONS + #################################################################################### + + let tmp0_1 = s0'; # First fold result, coefficient 1 + let tmp0_0 = s1'; # First fold result, coefficient 0 + let tmp1_1 = s2'; # Second fold result, coefficient 1 + let tmp1_0 = s3'; # Second fold result, coefficient 0 + let df3 = s4'; # Domain flag: 1 if d_seg=3, else 0 + let df2 = s5'; # Domain flag: 1 if d_seg=2, else 0 + let df1 = s6'; # Domain flag: 1 if d_seg=1, else 0 + let df0 = s7'; # Domain flag: 1 if d_seg=0, else 0 + let poe2 = s8'; # poe² + let tau_factor = s9'; # Tau factor for domain segment + let cptr_next = s10'; # Next layer pointer (cptr + 8) + let poe4 = s11'; # poe⁴ + let f_pos_out = s12'; # Folded position (preserved) + let ne1 = s13'; # New folded result, coefficient 1 + let ne0 = s14'; # New folded result, coefficient 0 + # s15' = eptr (from overflow table, not constrained here) + + #################################################################################### + # HELPER REGISTERS + #################################################################################### + + let ev0 = h0; # Evaluation point, coefficient 0 (α/x) + let ev1 = h1; # Evaluation point, coefficient 1 + let es0 = h2; # Squared evaluation point, coefficient 0 + let es1 = h3; # Squared evaluation point, coefficient 1 + let x = h4; # Domain value at query position + let x_inv = h5; # Inverse of domain value + + #################################################################################### + # GROUP 1: DOMAIN SEGMENT ONE-HOT ENCODING + #################################################################################### + + # Constraint 1.1: Each domain flag must be binary (0 or 1) + enf df3 * (df3 - 1) = 0; # degree 2 + enf df2 * (df2 - 1) = 0; # degree 2 + enf df1 * (df1 - 1) = 0; # degree 2 + enf df0 * (df0 - 1) = 0; # degree 2 + + # Constraint 1.2: Exactly one flag is active (one-hot encoding) + enf df0 + df1 + df2 + df3 = 1; # degree 1 + + # Constraint 1.3: Flags encode domain segment + # Formula: d_seg = (1×df0 + 2×df1 + 3×df2 + 4×df3) - 1 + # Maps: df0=1 → 0, df1=1 → 1, df2=1 → 2, df3=1 → 3 + enf d_seg = (df0 + 2 * df1 + 3 * df2 + 4 * df3) - 1; # degree 2 + + #################################################################################### + # GROUP 2: TAU FACTOR COMPUTATION + #################################################################################### + + # Constraint 2.1: Tau factor as weighted sum of one-hot flags + # tau_factor = df0×1 + df1×τ⁻¹ + df2×τ⁻² + df3×τ⁻³ + enf tau_factor = df0 * 1 + + df1 * TAU_INV + + df2 * TAU_INV2 + + df3 * TAU_INV3; # degree 2 + + #################################################################################### + # GROUP 3: DOMAIN VALUE AND INVERSE + #################################################################################### + + # Constraint 3.1: X computation via inverse relationship + # From: x = poe / tau_factor × DOMAIN_OFFSET + # Rearranged: x × tau_factor = poe × DOMAIN_OFFSET + enf x * tau_factor = poe * DOMAIN_OFFSET; # degree 2 + + # Constraint 3.2: X inverse verification + enf x * x_inv = 1; # degree 2 + + #################################################################################### + # GROUP 4: EVALUATION POINTS + #################################################################################### + + # Constraint 4.1: Evaluation point ev = α × x_inv + # Extension field: (α.0, α.1) × (x_inv, 0) + # Simplified: (α.0 × x_inv, α.1 × x_inv) + enf ev0 = alpha_0 * x_inv; # degree 2 + enf ev1 = alpha_1 * x_inv; # degree 2 + + # Constraint 4.2: Squared evaluation point es = ev² + # Extension field squaring: (a0, a1)² = (a0² - 2a1², 2a0·a1 - a1²) + enf es0 = ev0 * ev0 - 2 * ev1 * ev1; # degree 2 + enf es1 = 2 * ev0 * ev1 - ev1 * ev1; # degree 2 + + #################################################################################### + # GROUP 5: FIRST-LEVEL FOLDING + #################################################################################### + # fold2(a, b, e) ≡ 2×result = (a + b) + (a - b) × e + + # Constraint 5.1: tmp0 = fold2(q0, q2, ev) + # Query points: q0 = (v0, v1), q2 = (v4, v5) + let sum0_0 = v0 + v4; + let sum0_1 = v1 + v5; + let diff0_0 = v0 - v4; + let diff0_1 = v1 - v5; + + # Extension field multiplication: (diff0_0, diff0_1) × (ev0, ev1) + # Product: (diff0_0×ev0 - 2×diff0_1×ev1, (diff0_0+diff0_1)×(ev0+ev1) - diff0_0×ev0) + enf 2 * tmp0_0 = sum0_0 + diff0_0 * ev0 - 2 * diff0_1 * ev1; # degree 2 + enf 2 * tmp0_1 = sum0_1 + (diff0_0 + diff0_1) * (ev0 + ev1) - diff0_0 * ev0; # degree 2 + + # Constraint 5.2: tmp1 = fold2(q1, q3, ev × τ⁻¹) + # Query points: q1 = (v2, v3), q3 = (v6, v7) + # ev × τ⁻¹ = (ev0×τ⁻¹, ev1×τ⁻¹) (scalar multiplication) + let ev_tau_0 = ev0 * TAU_INV; + let ev_tau_1 = ev1 * TAU_INV; + + let sum1_0 = v2 + v6; + let sum1_1 = v3 + v7; + let diff1_0 = v2 - v6; + let diff1_1 = v3 - v7; + + # Extension field multiplication: (diff1_0, diff1_1) × (ev_tau_0, ev_tau_1) + enf 2 * tmp1_0 = sum1_0 + diff1_0 * ev_tau_0 - 2 * diff1_1 * ev_tau_1; # degree 2 + enf 2 * tmp1_1 = sum1_1 + (diff1_0 + diff1_1) * (ev_tau_0 + ev_tau_1) - diff1_0 * ev_tau_0; # degree 2 + + #################################################################################### + # GROUP 6: SECOND-LEVEL FOLDING + #################################################################################### + + # Constraint 6.1: result = fold2(tmp0, tmp1, es) + let sum_final_0 = tmp0_0 + tmp1_0; + let sum_final_1 = tmp0_1 + tmp1_1; + let diff_final_0 = tmp0_0 - tmp1_0; + let diff_final_1 = tmp0_1 - tmp1_1; + + # Extension field multiplication: (diff_final_0, diff_final_1) × (es0, es1) + enf 2 * ne0 = sum_final_0 + diff_final_0 * es0 - 2 * diff_final_1 * es1; # degree 2 + enf 2 * ne1 = sum_final_1 + (diff_final_0 + diff_final_1) * (es0 + es1) - diff_final_0 * es0; # degree 2 + + #################################################################################### + # GROUP 7: PREVIOUS LAYER VERIFICATION + #################################################################################### + + # Constraint 7.1: Verify q_{d_seg} = pe (one-hot selection) + # Only the matching query point contributes as only one flag can be set + enf (v0 - pe0) * df0 + (v2 - pe0) * df1 + (v4 - pe0) * df2 + (v6 - pe0) * df3 = 0; # degree 2 + enf (v1 - pe1) * df0 + (v3 - pe1) * df1 + (v5 - pe1) * df2 + (v7 - pe1) * df3 = 0; # degree 2 + + #################################################################################### + # GROUP 8: POWER OF DOMAIN GENERATOR + #################################################################################### + + # Constraint 8.1: poe² = poe × poe + enf poe2 = poe * poe; # degree 2 + + # Constraint 8.2: poe⁴ = poe² × poe² + enf poe4 = poe2 * poe2; # degree 2 + + #################################################################################### + # GROUP 9: MEMORY POINTER AND POSITION + #################################################################################### + + # Constraint 9.1: Increment memory pointer by 8 + enf cptr_next = cptr + 8; # degree 1 + + # Constraint 9.2: Preserve folded position + enf f_pos_out = f_pos; # degree 1 +} + +# SPLIT operation: Flow control operation for conditional execution (high-degree) +# Stack behavior: [condition, ...] -> [...] removes condition and branches (left shift - decreases depth by 1) +ev split_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: condition is consumed (unconstrained - handled by flow control) + # Positions 0-14: Left shift by 1 (removes condition from stack) + enf s0' = s1; enf s1' = s2; enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; + enf s8' = s9; enf s9' = s10; enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + # s15' comes from overflow table or is 0 (handled by left_shift_zero_insertion) +} + +# LOOP operation: Flow control operation for iterative execution (high-degree) +# Stack behavior: [condition, ...] -> [...] removes condition and loops (left shift - decreases depth by 1) +ev loop_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: condition is consumed (unconstrained - handled by flow control) + # Positions 0-14: Left shift by 1 (removes condition from stack) + enf s0' = s1; enf s1' = s2; enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; + enf s8' = s9; enf s9' = s10; enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + # s15' comes from overflow table or is 0 (handled by left_shift_zero_insertion) +} + +# DYN operation: Execute code block dynamically without context switch +ev dyn_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Stack LEFT SHIFT: all elements shift up one position + enf s0' = s1; enf s1' = s2; enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; + enf s8' = s9; enf s9' = s10; enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + # s15' from overflow table or 0 (handled by left_shift_zero_insertion) +} + +########################################################################################## +# NO STACK SHIFT OPERATION CONSTRAINTS (MOVUP/MOVDN) +########################################################################################## + +# MOVUP2 operation: Move element at position 2 to the top +# Stack behavior: [a, b, c, d, ...] -> [c, a, b, d, ...] (no depth change) +ev movup2_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s2 (element from position 2 moves to top) + enf s0' = s2; + + # Position 1: Gets s0 (original top element moves down one position) + enf s1' = s0; + + # Position 2: Gets s1 (element from position 1 moves down one position) + enf s2' = s1; + + # Positions 3-15: Unchanged (all other elements stay in place) + enf s3' = s3; + enf s4' = s4; + enf s5' = s5; + enf s6' = s6; + enf s7' = s7; + enf s8' = s8; + enf s9' = s9; + enf s10' = s10; + enf s11' = s11; + enf s12' = s12; + enf s13' = s13; + enf s14' = s14; + enf s15' = s15; +} + +# MOVDN2 operation: Move top element down to position 2 +# Stack behavior: [a, b, c, d, ...] -> [b, c, a, d, ...] (no depth change) +ev movdn2_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s1 (element from position 1 moves to top) + enf s0' = s1; + + # Position 1: Gets s2 (element from position 2 moves up one position) + enf s1' = s2; + + # Position 2: Gets s0 (original top element moves down to position 2) + enf s2' = s0; + + # Positions 3-15: Unchanged (all other elements stay in place) + enf s3' = s3; + enf s4' = s4; + enf s5' = s5; + enf s6' = s6; + enf s7' = s7; + enf s8' = s8; + enf s9' = s9; + enf s10' = s10; + enf s11' = s11; + enf s12' = s12; + enf s13' = s13; + enf s14' = s14; + enf s15' = s15; +} + +# MOVUP3 operation: Move element at position 3 to the top +# Stack behavior: [a, b, c, d, ...] -> [d, a, b, c, ...] (no depth change) +ev movup3_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s3 (element from position 3 moves to top) + enf s0' = s3; + # Position 1: Gets s0 (original top element moves down one position) + enf s1' = s0; + # Position 2: Gets s1 (element from position 1 moves down one position) + enf s2' = s1; + # Position 3: Gets s2 (element from position 2 moves down one position) + enf s3' = s2; + # Positions 4-15: Unchanged (all other elements stay in place) + enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVDN3 operation: Move top element to position 3 +# Stack behavior: [a, b, c, d, ...] -> [b, c, d, a, ...] (no depth change) +ev movdn3_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s1 (element from position 1 moves to top) + enf s0' = s1; + # Position 1: Gets s2 (element from position 2 moves up one position) + enf s1' = s2; + # Position 2: Gets s3 (element from position 3 moves up one position) + enf s2' = s3; + # Position 3: Gets s0 (original top element moves down to position 3) + enf s3' = s0; + # Positions 4-15: Unchanged (all other elements stay in place) + enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVUP4 operation: Move element at position 4 to the top +# Stack behavior: [a, b, c, d, e, ...] -> [e, a, b, c, d, ...] (no depth change) +ev movup4_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s4 (element from position 4 moves to top) + enf s0' = s4; + # Position 1: Gets s0 (original top element moves down one position) + enf s1' = s0; + # Position 2: Gets s1 (element from position 1 moves down one position) + enf s2' = s1; + # Position 3: Gets s2 (element from position 2 moves down one position) + enf s3' = s2; + # Position 4: Gets s3 (element from position 3 moves down one position) + enf s4' = s3; + # Positions 5-15: Unchanged (all other elements stay in place) + enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVDN4 operation: Move top element to position 4 +# Stack behavior: [a, b, c, d, e, ...] -> [b, c, d, e, a, ...] (no depth change) +ev movdn4_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s1 (element from position 1 moves to top) + enf s0' = s1; + # Position 1: Gets s2 (element from position 2 moves up one position) + enf s1' = s2; + # Position 2: Gets s3 (element from position 3 moves up one position) + enf s2' = s3; + # Position 3: Gets s4 (element from position 4 moves up one position) + enf s3' = s4; + # Position 4: Gets s0 (original top element moves down to position 4) + enf s4' = s0; + # Positions 5-15: Unchanged (all other elements stay in place) + enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVUP5 operation: Move element at position 5 to the top +# Stack behavior: [a, b, c, d, e, f, ...] -> [f, a, b, c, d, e, ...] (no depth change) +ev movup5_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s5 (element from position 5 moves to top) + enf s0' = s5; + # Position 1: Gets s0 (original top element moves down one position) + enf s1' = s0; + # Position 2: Gets s1 (element from position 1 moves down one position) + enf s2' = s1; + # Position 3: Gets s2 (element from position 2 moves down one position) + enf s3' = s2; + # Position 4: Gets s3 (element from position 3 moves down one position) + enf s4' = s3; + # Position 5: Gets s4 (element from position 4 moves down one position) + enf s5' = s4; + # Positions 6-15: Unchanged (all other elements stay in place) + enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVDN5 operation: Move top element to position 5 +# Stack behavior: [a, b, c, d, e, f, ...] -> [b, c, d, e, f, a, ...] (no depth change) +ev movdn5_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s1 (element from position 1 moves to top) + enf s0' = s1; + # Position 1: Gets s2 (element from position 2 moves up one position) + enf s1' = s2; + # Position 2: Gets s3 (element from position 3 moves up one position) + enf s2' = s3; + # Position 3: Gets s4 (element from position 4 moves up one position) + enf s3' = s4; + # Position 4: Gets s5 (element from position 5 moves up one position) + enf s4' = s5; + # Position 5: Gets s0 (original top element moves down to position 5) + enf s5' = s0; + # Positions 6-15: Unchanged (all other elements stay in place) + enf s6' = s6; enf s7' = s7; enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVUP6 operation: Move element at position 6 to the top +# Stack behavior: [a, b, c, d, e, f, g, ...] -> [g, a, b, c, d, e, f, ...] (no depth change) +ev movup6_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s6 (element from position 6 moves to top) + enf s0' = s6; + # Position 1: Gets s0 (original top element moves down one position) + enf s1' = s0; + # Position 2: Gets s1 (element from position 1 moves down one position) + enf s2' = s1; + # Position 3: Gets s2 (element from position 2 moves down one position) + enf s3' = s2; + # Position 4: Gets s3 (element from position 3 moves down one position) + enf s4' = s3; + # Position 5: Gets s4 (element from position 4 moves down one position) + enf s5' = s4; + # Position 6: Gets s5 (element from position 5 moves down one position) + enf s6' = s5; + # Positions 7-15: Unchanged (all other elements stay in place) + enf s7' = s7; enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVDN6 operation: Move top element to position 6 +# Stack behavior: [a, b, c, d, e, f, g, ...] -> [b, c, d, e, f, g, a, ...] (no depth change) +ev movdn6_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s1 (element from position 1 moves to top) + enf s0' = s1; + # Position 1: Gets s2 (element from position 2 moves up one position) + enf s1' = s2; + # Position 2: Gets s3 (element from position 3 moves up one position) + enf s2' = s3; + # Position 3: Gets s4 (element from position 4 moves up one position) + enf s3' = s4; + # Position 4: Gets s5 (element from position 5 moves up one position) + enf s4' = s5; + # Position 5: Gets s6 (element from position 6 moves up one position) + enf s5' = s6; + # Position 6: Gets s0 (original top element moves down to position 6) + enf s6' = s0; + # Positions 7-15: Unchanged (all other elements stay in place) + enf s7' = s7; enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVUP7 operation: Move element at position 7 to the top +# Stack behavior: [a, b, c, d, e, f, g, h, ...] -> [h, a, b, c, d, e, f, g, ...] (no depth change) +ev movup7_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s7 (element from position 7 moves to top) + enf s0' = s7; + # Position 1: Gets s0 (original top element moves down one position) + enf s1' = s0; + # Position 2: Gets s1 (element from position 1 moves down one position) + enf s2' = s1; + # Position 3: Gets s2 (element from position 2 moves down one position) + enf s3' = s2; + # Position 4: Gets s3 (element from position 3 moves down one position) + enf s4' = s3; + # Position 5: Gets s4 (element from position 4 moves down one position) + enf s5' = s4; + # Position 6: Gets s5 (element from position 5 moves down one position) + enf s6' = s5; + # Position 7: Gets s6 (element from position 6 moves down one position) + enf s7' = s6; + # Positions 8-15: Unchanged (all other elements stay in place) + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVDN7 operation: Move top element to position 7 +# Stack behavior: [a, b, c, d, e, f, g, h, ...] -> [b, c, d, e, f, g, h, a, ...] (no depth change) +ev movdn7_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s1 (element from position 1 moves to top) + enf s0' = s1; + # Position 1: Gets s2 (element from position 2 moves up one position) + enf s1' = s2; + # Position 2: Gets s3 (element from position 3 moves up one position) + enf s2' = s3; + # Position 3: Gets s4 (element from position 4 moves up one position) + enf s3' = s4; + # Position 4: Gets s5 (element from position 5 moves up one position) + enf s4' = s5; + # Position 5: Gets s6 (element from position 6 moves up one position) + enf s5' = s6; + # Position 6: Gets s7 (element from position 7 moves up one position) + enf s6' = s7; + # Position 7: Gets s0 (original top element moves down to position 7) + enf s7' = s0; + # Positions 8-15: Unchanged (all other elements stay in place) + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVUP8 operation: Move element at position 8 to the top +# Stack behavior: [a, b, c, d, e, f, g, h, i, ...] -> [i, a, b, c, d, e, f, g, h, ...] (no depth change) +ev movup8_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s8 (element from position 8 moves to top) + enf s0' = s8; + # Position 1: Gets s0 (original top element moves down one position) + enf s1' = s0; + # Position 2: Gets s1 (element from position 1 moves down one position) + enf s2' = s1; + # Position 3: Gets s2 (element from position 2 moves down one position) + enf s3' = s2; + # Position 4: Gets s3 (element from position 3 moves down one position) + enf s4' = s3; + # Position 5: Gets s4 (element from position 4 moves down one position) + enf s5' = s4; + # Position 6: Gets s5 (element from position 5 moves down one position) + enf s6' = s5; + # Position 7: Gets s6 (element from position 6 moves down one position) + enf s7' = s6; + # Position 8: Gets s7 (element from position 7 moves down one position) + enf s8' = s7; + # Positions 9-15: Unchanged (all other elements stay in place) + enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MOVDN8 operation: Move top element to position 8 +# Stack behavior: [a, b, c, d, e, f, g, h, i, ...] -> [b, c, d, e, f, g, h, i, a, ...] (no depth change) +ev movdn8_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s1 (element from position 1 moves to top) + enf s0' = s1; + # Position 1: Gets s2 (element from position 2 moves up one position) + enf s1' = s2; + # Position 2: Gets s3 (element from position 3 moves up one position) + enf s2' = s3; + # Position 3: Gets s4 (element from position 4 moves up one position) + enf s3' = s4; + # Position 4: Gets s5 (element from position 5 moves up one position) + enf s4' = s5; + # Position 5: Gets s6 (element from position 6 moves up one position) + enf s5' = s6; + # Position 6: Gets s7 (element from position 7 moves up one position) + enf s6' = s7; + # Position 7: Gets s8 (element from position 8 moves up one position) + enf s7' = s8; + # Position 8: Gets s0 (original top element moves down to position 8) + enf s8' = s0; + # Positions 9-15: Unchanged (all other elements stay in place) + enf s9' = s9; enf s10' = s10; enf s11' = s11; + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +########################################################################################## +# NO STACK SHIFT OPERATION CONSTRAINTS (FIELD, SYSTEM, I/O, WORD, CRYPTO) +########################################################################################## + +# EQZ operation: Test if top element equals zero (no stack depth change) +# Stack behavior: [a, ...] -> [a == 0, ...] (no depth change) +# Uses helper register h0 as witness for computing inverse when s0 ≠ 0 +ev eqz_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0]) { + # Position 0: Gets result of (s0 == 0) - zero test + # Constraint 1: s0' * s0 = 0 (degree 2) + # - If s0 = 0: this is satisfied for any s0' + # - If s0 ≠ 0: this forces s0' = 0 + enf s0' * s0 = 0; + + # Constraint 2: s0' - (1 - s0 * h0) = 0, or equivalently: s0' = 1 - s0 * h0 (degree 2) + # - If s0 = 0: h0 can be anything, and s0' = 1 - 0 = 1 + # - If s0 ≠ 0: prover sets h0 = s0^(-1), so s0' = 1 - s0 * s0^(-1) = 1 - 1 = 0 + # Together with constraint 1, this ensures (s0' = 1 iff s0 = 0) and (s0' is binary) + enf s0' = 1 - (s0 * h0); + + # Positions 1-15: Unchanged (all other elements stay in place) + enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; + enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# NEG operation: Compute additive inverse (no stack depth change) +# Stack behavior: [a, ...] -> [-a, ...] (no depth change) +ev neg_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets additive inverse of s0 + enf s0' + s0 = 0; + # Positions 1-15: Unchanged (all other elements stay in place) + enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; + enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# INV operation: Compute multiplicative inverse (no stack depth change) +# Stack behavior: [a, ...] -> [1/a, ...] (no depth change) +ev inv_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets multiplicative inverse of s0 + # Constraint: s0' must be the multiplicative inverse of s0 in the field + # Note: In the Miden VM, calling INV on 0 will cause a runtime trap/error + # The constraint system assumes s0 ≠ 0 (zero inputs are handled at the VM level) + enf s0' * s0 = 1; # Multiplicative inverse: s0' = s0^(-1) + + # Positions 1-15: Unchanged (all other elements stay in place) + enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; + enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# INCR operation: Add 1 to top element (no stack depth change) +# Stack behavior: [a, ...] -> [a + 1, ...] (no depth change) +ev incr_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets s0 + 1 + enf s0' = s0 + 1; + # Positions 1-15: Unchanged (all other elements stay in place) + enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; + enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# NOT operation: Compute logical NOT (no stack depth change) +# Stack behavior: [a, ...] -> [!a, ...] (no depth change) +ev not_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Position 0: Gets logical NOT of s0 + # Constraint: s0 must be boolean (0 or 1), and s0' = 1 - s0 + # This ensures proper boolean NOT operation in the field + enf is_binary([s0]); # s0 must be 0 or 1 (boolean constraint) + enf s0' = 1 - s0; # Boolean NOT: if s0=0 then s0'=1, if s0=1 then s0'=0 + + # Positions 1-15: Unchanged (all other elements stay in place) + enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; + enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# EXPACC operation: Exponentiate and accumulate (no stack depth change) +# Stack behavior: [bit, base, acc, exp, ...] -> [bit', base', acc', exp', ...] (no depth change) +# Performs one round of exponentiation via repeated squaring +# Uses helper register h0 to compute conditional accumulator update +ev expacc_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, h0]) { + # Position 0 (bit): Must be binary (0 or 1) + # Constraint: s0'^2 - s0' = 0, which is s0' * (s0' - 1) = 0 + enf s0' * (s0' - 1) = 0; + + # Position 1 (base): Square the base for next iteration + # Constraint: s1' - s1^2 = 0, so s1' = s1^2 + enf s1' = s1 * s1; + + # Helper register h0: Computes the multiplier for accumulator update + # h0 = ((s1 - 1) * s0') + 1 + # - If s0' = 1 (bit set): h0 = (s1 - 1) + 1 = s1 (multiply acc by base) + # - If s0' = 0 (bit clear): h0 = 0 + 1 = 1 (keep acc unchanged) + let h0_expected = (s1 - 1) * s0' + 1; + enf h0 = h0_expected; + + # Position 2 (acc): Update accumulator conditionally based on bit + # Constraint: s2' - s2 * h0 = 0, so s2' = s2 * h0 + enf s2' = s2 * h0; + + # Position 3 (exp): Exponent reconstruction/bit aggregation + # Constraint: s3' = s3 * 2 + s0' (degree 1) + # This constraint builds up the exponent by shifting and adding bits + # Equivalently: s3 = (s3' - s0') / 2, extracting bit s0' from s3 + # The operation processes exponent bits to compute base^exp via repeated squaring + enf s3' = (s3 * 2) + s0'; + + # Positions 4-15: Unchanged (all other elements stay in place) + enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; + enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# CALLER operation: Get hash of the calling function (no stack depth change) +# Stack behavior: [...] -> [fn_hash[0], fn_hash[1], fn_hash[2], fn_hash[3], ...] (no depth change) +# Loads the function hash (4 elements) from system state onto top of stack +# Note: CALLER can only be executed within a SYSCALL; constraints enforced in system.air +ev caller_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, + fn_hash_0, fn_hash_1, fn_hash_2, fn_hash_3]) { + # Positions 0-3: Load function hash word from system state + enf s0' = fn_hash_0; + enf s1' = fn_hash_1; + enf s2' = fn_hash_2; + enf s3' = fn_hash_3; + + # Positions 4-15: Unchanged (all other elements stay in place) + enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; + enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# EMIT operation: Emit an event with the specified event ID (no stack depth change) +# Stack behavior: [event_id, ...] -> [event_id, ...] (no depth change) +ev emit_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + enf s0' = s0; enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# MLOAD operation: Load word from memory (no stack depth change) +# Stack behavior: [addr, ...] -> [mem[addr], ...] (no depth change) +ev mload_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, system_ctx, system_clk]) { + # Position 0: Overwritten by memory value (unconstrained) + # Positions 1-15: Unchanged + enf s1' = s1; enf s2' = s2; enf s3' = s3; enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; + enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; + + # Insert memory read element request to chiplets bus + # MLOAD reads a single element from memory address s0 in the current execution context + # The value read will be placed in s0' (which is unconstrained here, but constrained by memory chiplet response) + bus_6_chiplets_bus.insert(MEMREADELEMENT, system_ctx, s0, system_clk, s0') when 1; +} + +# ADVPOPW operation: Pop word from advice stack (no stack depth change) +# Stack behavior: [...] -> [advice_word_elem0, advice_word_elem1, advice_word_elem2, advice_word_elem3, ...] (no depth change) +ev advpopw_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Positions 0-3: Overwritten by advice stack values (unconstrained here) + # Positions 4-15: Unchanged + enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; + enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# SWAPW operation: Swap top word with second word (no stack depth change) +# Stack behavior: [a0, a1, a2, a3, b0, b1, b2, b3, ...] -> [b0, b1, b2, b3, a0, a1, a2, a3, ...] (no depth change) +ev swapw_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Swap first word (positions 0-3) with second word (positions 4-7) + enf s0' = s4; enf s1' = s5; enf s2' = s6; enf s3' = s7; + enf s4' = s0; enf s5' = s1; enf s6' = s2; enf s7' = s3; + # Positions 8-15: Unchanged (all other elements stay in place) + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# SWAPW2 operation: Swap top word with third word (no stack depth change) +# Stack behavior: [a0, a1, a2, a3, b0, b1, b2, b3, c0, c1, c2, c3, ...] -> [c0, c1, c2, c3, b0, b1, b2, b3, a0, a1, a2, a3, ...] (no depth change) +ev swapw2_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Swap first word (positions 0-3) with third word (positions 8-11) + enf s0' = s8; enf s1' = s9; enf s2' = s10; enf s3' = s11; + # Second word (positions 4-7) stays in place + enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; + # Third word (positions 8-11) gets original first word + enf s8' = s0; enf s9' = s1; enf s10' = s2; enf s11' = s3; + # Positions 12-15: Unchanged (all other elements stay in place) + enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +# SWAPW3 operation: Swap top word with fourth word (no stack depth change) +# Stack behavior: [a0, a1, a2, a3, b0, b1, b2, b3, c0, c1, c2, c3, d0, d1, d2, d3] -> [d0, d1, d2, d3, b0, b1, b2, b3, c0, c1, c2, c3, a0, a1, a2, a3] (no depth change) +ev swapw3_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Swap first word (positions 0-3) with fourth word (positions 12-15) + enf s0' = s12; enf s1' = s13; enf s2' = s14; enf s3' = s15; + # Second and third words (positions 4-11) stay in place + enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; + enf s8' = s8; enf s9' = s9; enf s10' = s10; enf s11' = s11; + # Fourth word (positions 12-15) gets original first word + enf s12' = s0; enf s13' = s1; enf s14' = s2; enf s15' = s3; +} + +# SWAPDW operation: Swap top double-word with second double-word (no stack depth change) +# Stack behavior: [a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7] -> [b0, b1, b2, b3, b4, b5, b6, b7, a0, a1, a2, a3, a4, a5, a6, a7] (no depth change) +ev swapdw_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Swap first double-word (positions 0-7) with second double-word (positions 8-15) + enf s0' = s8; enf s1' = s9; enf s2' = s10; enf s3' = s11; + enf s4' = s12; enf s5' = s13; enf s6' = s14; enf s7' = s15; + enf s8' = s0; enf s9' = s1; enf s10' = s2; enf s11' = s3; + enf s12' = s4; enf s13' = s5; enf s14' = s6; enf s15' = s7; +} + +# EXT2MUL operation: Multiply two quadratic extension field elements (no stack depth change) +# Stack behavior: [b0, b1, a0, a1, ...] -> [b0, b1, c0, c1, ...] where c = a * b in 𝔽ₚ[x]/(x² - 7) +# Extension field elements: a = a0 + a1·x, b = b0 + b1·x (LE convention: base coeff on top) +# Multiplication result: c = (a0·b0 + 7·a1·b1) + (a0·b1 + a1·b0)·x +ev ext2mul_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15]) { + # Stack positions (LE): s0 = b0 (base), s1 = b1 (x coeff), s2 = a0 (base), s3 = a1 (x coeff) + # Result positions: s0' = b0, s1' = b1, s2' = c0 (base), s3' = c1 (x coeff) + + # Position 0 (b0): Unchanged (remains on stack) + enf s0' = s0; + + # Position 1 (b1): Unchanged (remains on stack) + enf s1' = s1; + + # Position 2 (c0): Base coefficient of product + # Formula: c0 = a0·b0 + 7·a1·b1 = s2·s0 + 7·s3·s1 + enf s2' = s0 * s2 + 7 * s1 * s3; + + # Position 3 (c1): x coefficient of product using Karatsuba optimization + # Formula: c1 = a0·b1 + a1·b0 = (a0 + a1)(b0 + b1) - a0·b0 - a1·b1 + # = (s2 + s3)(s0 + s1) - s2·s0 - s3·s1 + enf s3' = (s0 + s1) * (s2 + s3) - s0 * s2 - s1 * s3; + + # Positions 4-15: Unchanged (all other elements stay in place) + enf s4' = s4; enf s5' = s5; enf s6' = s6; enf s7' = s7; enf s8' = s8; + enf s9' = s9; enf s10' = s10; enf s11' = s11; enf s12' = s12; enf s13' = s13; enf s14' = s14; enf s15' = s15; +} + +########################################################################################## +# CONTEXT SWITCHING OPERATIONS +########################################################################################## + +# CALL operation: Call a function and start a new execution context +ev call_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, b0, b1]) { + # Stack elements s0-s15 remain unchanged (no shift) + + # Reset stack depth and overflow address for new context + enf b0' = 16; + enf b1' = 0; +} + +# SYSCALL operation: Call kernel function in root context +ev syscall_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, b0, b1]) { + # Stack elements s0-s15 remain unchanged (no shift) + + # Reset stack depth and overflow address for root context + enf b0' = 16; + enf b1' = 0; +} + +# DYNCALL operation: Call function dynamically with hash from memory +ev dyncall_operation_constraints([s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, b0, b1]) { + # Stack LEFT SHIFT: all elements shift up one position + enf s0' = s1; enf s1' = s2; enf s2' = s3; enf s3' = s4; enf s4' = s5; enf s5' = s6; enf s6' = s7; enf s7' = s8; + enf s8' = s9; enf s9' = s10; enf s10' = s11; enf s11' = s12; enf s12' = s13; enf s13' = s14; enf s14' = s15; + # s15' from overflow table or 0 (handled by left_shift_zero_insertion) + # Note: overflow-table removal for DYNCALL uses decoder hasher state, not b1'. + + # Reset stack depth and overflow address for new context + enf b0' = 16; + enf b1' = 0; +} diff --git a/constraints/system.air b/constraints/system.air new file mode 100644 index 000000000..0a37fa41b --- /dev/null +++ b/constraints/system.air @@ -0,0 +1,218 @@ +########################################################################################## +# SYSTEM CONSTRAINTS MODULE +########################################################################################## +# +# System module is responsible for managing system data, including the current VM cycle +# (clk), the free memory pointer (fmp) used for specifying the region of memory available +# to procedure locals, and the current and parent execution contexts. +# +# SYSTEM COLUMN LAYOUT (8 columns): +# ┌─────────┬──────────────────────────────────────────────────────────────────────┐ +# │ Column │ Purpose │ +# ├─────────┼──────────────────────────────────────────────────────────────────────┤ +# │ 0 │ clk - VM execution clock (increments each cycle) │ +# │ 1 │ [UNUSED] Placeholder for trace layout compatibility │ +# │ 2 │ ctx - Current execution context │ +# │ 3 │ [UNUSED] Placeholder for trace layout compatibility │ +# │ 4-7 │ fn_hash - Current function digest (4 elements) │ +# └─────────┴──────────────────────────────────────────────────────────────────────┘ +# +# NOTE: Columns 1 and 3 are logically removed but physically retained as placeholders +# to maintain trace layout compatibility with open PRs. These correspond to the removed +# `fmp` (free memory pointer) and `in_syscall` (syscall flag) columns from the Miden VM. +# +# More precisely, recent changes in Miden VM (PRs 2296, 2308): +# - `fmp` is now stored in memory at address 2^32-1, not in a trace columns +# - `in_syscall` flag was removed; syscall context is determined by ctx=0 +# TODO: These columns will be fully removed once all open PRs are merged +# +# PROCEDURE EXECUTION MODES: +# +# The Miden VM supports five different ways to execute procedures, each with distinct +# semantics for context management and caller identification: +# +# ┌──────────┬─────────┬──────────────┬──────────────────────────────────────────────┐ +# │ Operation│ ctx' │ fn_hash' │ Purpose │ +# ├──────────┼─────────┼──────────────┼──────────────────────────────────────────────┤ +# │ EXEC │ ctx │ fn_hash │ Inline execution (assembler-level) │ +# │ CALL │ clk + 1 │ Load new │ Call known procedure (new context) │ +# │ SYSCALL │ 0 │ fn_hash │ Call kernel (preserves caller hash) │ +# │ DYN │ ctx │ fn_hash │ Dynamic inline exec (preserves caller hash) │ +# │ DYNCALL │ clk + 1 │ Load new │ Dynamic call (new context) │ +# └──────────┴─────────┴──────────────┴──────────────────────────────────────────────┘ +# +# Note on fn_hash behavior: +# - "Load new": fn_hash' = target procedure hash (from decoder h0-h3) +# - "fn_hash": fn_hash' = fn_hash (preserved/unchanged) +# +# DETAILED SEMANTICS: +# +# 1. EXEC (MASM-level, not visible to VM): +# - Assembler-level inline expansion (no VM instruction) +# - Not enforced by AIR constraints +# +# 2. CALL (opcode 108: 110_1100): +# - Creates NEW execution context (ctx' = clk + 1) +# - Loads NEW function hash (fn_hash' = target procedure hash) +# - Target hash known at compile time (in program MAST) +# - Used for calling procedures within same account/program +# +# 3. SYSCALL (opcode 104: 110_1000): +# - Jumps to ROOT CONTEXT (ctx' = 0, the kernel context) +# - PRESERVES caller's fn_hash (fn_hash' = fn_hash) +# - Target verified in kernel ROM at runtime +# - CRITICAL: Preserving fn_hash enables kernel to authenticate caller via +# the `caller` instruction, which returns fn_hash of calling procedure +# +# 4. DYN (opcode 88: 101_1000): +# - NO CONTEXT SWITCH (ctx' = ctx, remains in current context) +# - PRESERVES caller's fn_hash (fn_hash' = fn_hash) +# - Target hash loaded from memory at address s0 (runtime determined) +# - Used by kernel for dynamic procedure dispatch (e.g., exec_kernel_proc) +# - CRITICAL: Because DYN preserves fn_hash, the authentication chain works: +# User procedure → SYSCALL (preserves fn_hash) → DYN (preserves fn_hash) +# → kernel can use `caller` to get original user procedure hash +# +# 5. DYNCALL (opcode 92: 101_1100): +# - Creates NEW execution context (ctx' = clk + 1) +# - Loads NEW function hash (fn_hash' = target procedure hash) +# - Target hash loaded from memory at address s0 (runtime determined) +# - Used for calling procedures whose hash is only known at runtime +# - Example: note scripts, transaction scripts +# +# STACK BEHAVIOR: +# - CALL, SYSCALL: Reset stack depth to 16, preserving top 16 elements +# - DYNCALL: Resets stack depth to 16 AND shifts elements left by 1 position +# (the target hash is loaded from memory at address s0, not consumed from stack). +# The bottom element (s15') is pulled from the overflow table if available, or 0 if empty. +# - EXEC, DYN: No stack depth changes +# +# CONSTRAINT ENFORCEMENT: +# - EXEC: Not enforced (assembler-level transformation) +# - CALL, SYSCALL, DYNCALL: Enforced by system constraints (ctx, fn_hash transitions) +# - DYN: Enforced by DEFAULT constraints (all registers preserved except hasher) +# - END: Restores ctx and fn_hash from block stack +# +# STATUS: Partially implemented (missing bus integration) +# +# REFERENCES: +# - System Design: https://0xmiden.github.io/miden-vm/design/main.html +########################################################################################## + +mod system + +use utils::*; +use decoder::*; + +########################################################################################## +# SYSTEM CONSTRAINT IMPLEMENTATION +########################################################################################## + +# Main system constraint evaluator - ensures proper system state transitions +# Requires decoder columns for operation flags and function hash loading +ev system_transition([system[8], decoder[24]]) { + # Extract system columns + let clk = system[0]; + # system[1] - unused (placeholder) + let ctx = system[2]; + # system[3] - unused (placeholder) + let fn_hash_0 = system[4]; + let fn_hash_1 = system[5]; + let fn_hash_2 = system[6]; + let fn_hash_3 = system[7]; + + # Extract decoder columns needed for operation flags + let op_bit0 = decoder[1]; + let op_bit1 = decoder[2]; + let op_bit2 = decoder[3]; + let op_bit3 = decoder[4]; + let op_bit4 = decoder[5]; + let op_bit5 = decoder[6]; + let op_bit6 = decoder[7]; + let decoder_h0 = decoder[8]; + let decoder_h1 = decoder[9]; + let decoder_h2 = decoder[10]; + let decoder_h3 = decoder[11]; + let decoder_h4 = decoder[12]; + let decoder_h5 = decoder[13]; + let decoder_h6 = decoder[14]; + let decoder_h7 = decoder[15]; + let e0 = decoder[22]; + let e1 = decoder[23]; + + # Compute operation flags (needed for all constraints) + let op_bits = [op_bit0, op_bit1, op_bit2, op_bit3, op_bit4, op_bit5, op_bit6]; + let f_call = flag_call(op_bits, e1); + let f_syscall = flag_syscall(op_bits, e1); + let f_dyncall = flag_dyncall(op_bits, e0); + let f_end = flag_end(op_bits, e1); + + #################################################################################### + # SYSTEM CLOCK CONSTRAINT + #################################################################################### + + # Clock progression constraint (always active) + enf clk' = clk + 1; + + #################################################################################### + # EXECUTION CONTEXT CONSTRAINTS + #################################################################################### + # + # Execution context (ctx) determines memory isolation boundaries: + # - ctx = 0: Kernel/root context + # - ctx > 0: User contexts (one per CALL/DYNCALL) + # + # Note: DYN preserves ctx, meaning it executes in the current context without + # creating a new one. This enables kernel dynamic dispatch while maintaining + # the same memory space and execution environment. + # + #################################################################################### + + # CALL/DYNCALL: Create new context with ID = current_clk + 1 + enf ctx' = clk + 1 when (f_call + f_dyncall); + + # SYSCALL: Return to root context (ID = 0) + enf ctx' = 0 when f_syscall; + + # Default: Context unchanged for all other operations (including DYN) + # NOTE: END is handled by block stack table (restores previous ctx) + enf ctx' = ctx when !(f_call + f_syscall + f_dyncall + f_end); + + #################################################################################### + # FUNCTION HASH CONSTRAINTS + #################################################################################### + # + # The function hash (fn_hash) identifies the currently executing procedure and is + # critical for authorization. The `caller` instruction reads fn_hash to return the + # hash of the procedure that initiated the current execution context. + # + # CALLER instruction behavior: + # - Returns fn_hash of the caller that entered the current context (via CALL/DYNCALL) + # - In context 0 outside of SYSCALL scenarios, returns [0, 0, 0, 0] + # - In SYSCALL contexts, returns the hash of the SYSCALL initiator + # + # Only three types of operations modify fn_hash: + # 1. CALL/DYNCALL: Load new hash (enter new procedure context) + # 2. SYSCALL: Preserve hash (enables kernel to authenticate caller) + # 3. END: Restore hash from block stack (return to caller) + # + # Note: DYN falls into the "default" case where fn_hash is preserved. + # In procedure invocation authentication, SYSCALL → DYN maintains the caller's + # identity through dynamic dispatch, allowing `caller` to return the original procedure hash. + # + #################################################################################### + + # CALL/DYNCALL: Load function hash from decoder h0-h3 + enf fn_hash_0' = decoder_h0 when f_call + f_dyncall; + enf fn_hash_1' = decoder_h1 when f_call + f_dyncall; + enf fn_hash_2' = decoder_h2 when f_call + f_dyncall; + enf fn_hash_3' = decoder_h3 when f_call + f_dyncall; + + # Default: function hash remains unchanged for all other operations + # This includes: DYN (dynamic inline execution) and SYSCALL (kernel call) + # NOTE: END is handled by block stack table (restores fn_hash from caller) + enf fn_hash_0' = fn_hash_0 when !(f_call + f_dyncall + f_end); + enf fn_hash_1' = fn_hash_1 when !(f_call + f_dyncall + f_end); + enf fn_hash_2' = fn_hash_2 when !(f_call + f_dyncall + f_end); + enf fn_hash_3' = fn_hash_3 when !(f_call + f_dyncall + f_end); +} diff --git a/constraints/tests/miden_vm.rs b/constraints/tests/miden_vm.rs new file mode 100644 index 000000000..8509937d1 --- /dev/null +++ b/constraints/tests/miden_vm.rs @@ -0,0 +1,45 @@ +use std::sync::Arc; + +use air_codegen_ace::{build_ace_circuit, AceCircuit, AceNode}; +use air_ir::{compile, Air}; +use miden_diagnostics::{ + term::termcolor::ColorChoice, CodeMap, DefaultEmitter, DiagnosticsHandler, +}; +use winter_math::FieldElement; + +fn generate_circuit(source: &str) -> (Air, AceCircuit, AceNode) { + let code_map = Arc::new(CodeMap::new()); + let emitter = Arc::new(DefaultEmitter::new(ColorChoice::Auto)); + let diagnostics = DiagnosticsHandler::new(Default::default(), code_map.clone(), emitter); + + let air = air_parser::parse(&diagnostics, code_map, source) + .map_err(air_ir::CompileError::Parse) + .and_then(|program| compile(&diagnostics, program)) + .expect("lowering failed"); + + let (root, circuit) = build_ace_circuit(&air).expect("codegen failed"); + + (air, circuit, root) +} + +/// Loads the MidenVM AIR example +pub fn load_miden_vm_air() -> std::io::Result { + let crate_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap(); + let path = format!("{}/miden_vm.air", crate_dir); + let content = std::fs::read_to_string(path)?; + + Ok(content) +} + +#[test] +fn test_miden_vm_updated_air_randomized() { + let air_string = load_miden_vm_air().expect("unable to read MidenVM AIR"); + + let (_air, circuit, root_node) = generate_circuit(&air_string); + + // Provide dummy variable assignments since we are not generating valid ACE vars here + let dummy_inputs = vec![Default::default(); circuit.layout.num_inputs]; + let eval = circuit.eval(root_node, &dummy_inputs); + + assert_eq!(eval, <_ as FieldElement>::ZERO); +} diff --git a/constraints/utils.air b/constraints/utils.air new file mode 100644 index 000000000..fa363bd47 --- /dev/null +++ b/constraints/utils.air @@ -0,0 +1,186 @@ +########################################################################################## +# UTILITY CONSTRAINTS MODULE +########################################################################################## +# +# The Utils module provides fundamental constraint patterns and helper functions used +# throughout the Miden VM constraint system. These utilities ensure consistency and +# reusability across all VM components. +# +########################################################################################## + +mod utils + +########################################################################################## +# BINARY CONSTRAINT EVALUATORS +########################################################################################## + +# Ensures value is either 0 or 1 +# +# CONSTRAINT DEGREE: 2 +# +# USAGE PATTERN: +# ```air +# let flag = column[i]; +# enf is_binary([flag]); // Ensures flag ∈ {0, 1} +# ``` +ev is_binary([a]) { + enf a^2 = a; +} + +########################################################################################## +# STATE CONSISTENCY EVALUATORS +########################################################################################## + +# State persistence constraint - ensures values remain constant across cycles +# +# INTUITION: +# +# Many VM components require certain values to remain stable during specific +# operations or phases. This constraint enforces immutability when needed. +# +# CONSTRAINT DEGREE: 1 +# +# USAGE PATTERN: +# ```air +# let stable_value = column[i]; +# enf is_unchanged([stable_value]) when operation_active; +# ``` +ev is_unchanged([column]) { + enf column' = column; +} + +########################################################################################## +# LOGICAL OPERATION HELPERS +########################################################################################## + +# Binary negation function - computes logical NOT in finite field +# +# This is usually combined with another constraint to ensure booleaness +# +# CONSTRAINT DEGREE: 1 +# +# USAGE EXAMPLES: +# ```air +# let not_flag = binary_not(flag); // Simple negation +# let condition = flag * binary_not(other); // AND NOT pattern +# ``` +fn binary_not(a: felt) -> felt { + return 1 - a; +} + +# Binary constraint helper - returns 0 if input is binary (0 or 1), non-zero otherwise +# +# This function computes flag² - flag, which equals: +# - 0 when flag = 0 (since 0² - 0 = 0) +# - 0 when flag = 1 (since 1² - 1 = 0) +# - non-zero for any other value +# +# Usage: enf binary_constraint(x) = 0; // constrains x to be 0 or 1 +fn binary_constraint(flag: felt) -> felt { + return flag^2 - flag; +} + +########################################################################################## +# BOOLEAN ALGEBRA OPERATIONS +########################################################################################## + +# Logical AND: returns 1 if both a and b are 1, else 0 +# +# CONSTRAINT DEGREE: 2 +# +# USAGE EXAMPLES: +# ```air +# let result = binary_and(flag_a, flag_b); +# ``` +fn binary_and(a: felt, b: felt) -> felt { + return a * b; +} + +# Logical OR: returns 1 if either a or b is 1, else 0 +# +# Uses inclusion-exclusion principle: |A ∪ B| = |A| + |B| - |A ∩ B| +# +# CONSTRAINT DEGREE: 2 +# +# USAGE EXAMPLES: +# ```air +# let result = binary_or(flag_a, flag_b); +# ``` +fn binary_or(a: felt, b: felt) -> felt { + return a + b - a * b; +} + +# Logical XOR: returns 1 if exactly one of a or b is 1, else 0 +# +# CONSTRAINT DEGREE: 2 +# +# USAGE EXAMPLES: +# ```air +# let result = binary_xor(flag_a, flag_b); +# ``` +fn binary_xor(a: felt, b: felt) -> felt { + let ab = a * b; + return a + b - (ab + ab); +} + +########################################################################################## +# CONDITIONAL OPERATIONS +########################################################################################## + +# Conditional selection: returns if_true when condition=1, if_false when condition=0 +# +# This is a multiplexer function that selects between two values based on condition +# +# CONSTRAINT DEGREE: 2 +# +# USAGE EXAMPLES: +# ```air +# let result = select(condition, true_value, false_value); +# ``` +fn select(condition: felt, if_true: felt, if_false: felt) -> felt { + return condition * (if_true - if_false) + if_false; +} + +########################################################################################## +# OPERATION LABELS +########################################################################################## + +# Operation labels for bus communication +# +########################################################################################## + +# Hasher Chiplet Operation Labels +const HASHERLINEARHASH = 3; # Linear hash of n elements +const HASHERMPVERIFY = 11; # Merkle path verification +const HASHERMRUPDATEOLD = 7; # Merkle root update (old path) +const HASHERMRUPDATENEW = 15; # Merkle root update (new path) +const HASHERRETURNHASH = 1; # Return hash result (positions 4-7) +const HASHERRETURNSTATE = 9; # Return full state (all 12 elements) + +# Bitwise Chiplet Operation Labels +const BITWISEAND = 2; # Bitwise AND of two u32 values +const BITWISEXOR = 6; # Bitwise XOR of two u32 values + +# Memory Chiplet Operation Labels +const MEMWRITEELEMENT = 4; # Element write operation (1 element) +const MEMREADELEMENT = 12; # Element read operation (1 element) +const MEMWRITEWORD = 20; # Word write operation (4 elements) +const MEMREADWORD = 28; # Word read operation (4 elements) + +# ACE Chiplet Operation Label +const ACEINIT = 8; # ACE circuit initialization (uses bus_6_chiplets_bus) + +# Log Precompile Operation label +const LOGPRECOMPILE = 94; + +# Kernel ROM Chiplet Operation Labels +const KERNELPROCCALL = 16; # Kernel procedure call +const KERNELPROCINIT = 48; # Kernel procedure initialization + +########################################################################################## +# GENERAL CONSTANTS +########################################################################################## + +# ACE instruction encoding offsets +const ACEINSTRUCTIONIDONEOFFSET = 1073741824; # 2^30 +const ACEINSTRUCTIONIDTWOOFFSET = 1152921504606846976; # 2^60 diff --git a/mir/src/passes/translate.rs b/mir/src/passes/translate.rs index db342ecb7..e1e54acf9 100644 --- a/mir/src/passes/translate.rs +++ b/mir/src/passes/translate.rs @@ -695,7 +695,7 @@ impl<'a> MirBuilder<'a> { // At this point during compilation, fully-qualified identifiers can only possibly refer // to a periodic column, as all functions have been inlined, and constants propagated. ast::ResolvableIdentifier::Resolved(qual_ident) => { - if let Some(pc) = self.mir.periodic_columns.get(&qual_ident).cloned() { + if let Some(pc) = self.mir.periodic_columns.get(qual_ident).cloned() { let node = Value::builder() .value(SpannedMirValue { span: access.span(), @@ -706,7 +706,7 @@ impl<'a> MirBuilder<'a> { }) .build(); Ok(node) - } else if let Some(bus) = self.mir.constraint_graph().get_bus_link(&qual_ident) { + } else if let Some(bus) = self.mir.constraint_graph().get_bus_link(qual_ident) { let node = Value::builder() .value(SpannedMirValue { span: access.span(), @@ -714,6 +714,10 @@ impl<'a> MirBuilder<'a> { }) .build(); Ok(node) + } else if let Some(constant) = self.program.constants.get(qual_ident) { + // Handle qualified constant references that weren't inlined + // (e.g., constants used in comprehension iterables across modules) + self.translate_const(&constant.value, access.span()) } else { // This is a qualified reference that should have been eliminated // during inlining or constant propagation, but somehow slipped through. @@ -735,7 +739,7 @@ impl<'a> MirBuilder<'a> { }, // This must be one of public inputs or trace columns ast::ResolvableIdentifier::Global(ident) | ast::ResolvableIdentifier::Local(ident) => { - self.translate_symbol_access_global_or_local(&ident, access) + self.translate_symbol_access_global_or_local(ident, access) }, // These should have been eliminated by previous compiler passes ast::ResolvableIdentifier::Unresolved(_ident) => { @@ -1063,7 +1067,8 @@ impl<'a> MirBuilder<'a> { access: &'a ast::SymbolAccess, ) -> Option> { // If it's a slice access, we need to create a vector of MirAccessType::Index - if let AccessType::Slice(ast::RangeExpr { start, end, .. }) = &access.access_type { + if let AccessType::Slice(range) = &access.access_type { + let ast::RangeExpr { start, end, .. } = range.as_ref(); let ( ast::RangeBound::Const(Span { item: start, .. }), ast::RangeBound::Const(Span { item: end, .. }), diff --git a/parser/src/ast/expression.rs b/parser/src/ast/expression.rs index 97f26fa94..1ad12bb80 100644 --- a/parser/src/ast/expression.rs +++ b/parser/src/ast/expression.rs @@ -865,7 +865,7 @@ pub enum AccessType { #[default] Default, /// Access binds a sub-slice of a vector - Slice(RangeExpr), + Slice(Box), /// Access binds the value at a specific index of an aggregate value (i.e. vector or matrix) /// /// The result type may be either a scalar or a vector, depending on the type of the aggregate @@ -1073,7 +1073,7 @@ impl SymbolAccess { Err(InvalidAccessError::IndexOutOfBounds) }, Type::Vector(_) => Ok(Self { - access_type: AccessType::Slice(shifted), + access_type: AccessType::Slice(Box::new(shifted.clone())), ty: Some(Type::Vector(rlen)), ..self.clone() }), @@ -1081,7 +1081,7 @@ impl SymbolAccess { Err(InvalidAccessError::IndexOutOfBounds) }, Type::Matrix(_, cols) => Ok(Self { - access_type: AccessType::Slice(shifted), + access_type: AccessType::Slice(Box::new(shifted)), ty: Some(Type::Matrix(rlen, cols)), ..self.clone() }), diff --git a/parser/src/ast/trace.rs b/parser/src/ast/trace.rs index 5b26a05d0..71fab9071 100644 --- a/parser/src/ast/trace.rs +++ b/parser/src/ast/trace.rs @@ -287,7 +287,7 @@ impl TraceBinding { let range_expr1 = range_expr1.to_slice_range(); let combined_range = (range_expr.start + range_expr1.start)..(range_expr.end + range_expr1.end); - AccessType::Slice(combined_range.into()) + AccessType::Slice(Box::new(combined_range.into())) }, (AccessType::Slice(range_expr), AccessType::Index(index_expr)) => { let range_expr_usize = range_expr.to_slice_range(); diff --git a/parser/src/lexer/mod.rs b/parser/src/lexer/mod.rs index f354cf6f4..8265300ae 100644 --- a/parser/src/lexer/mod.rs +++ b/parser/src/lexer/mod.rs @@ -644,10 +644,9 @@ where match num.parse::() { Ok(i) => Token::Num(i), - Err(err) => Token::Error(LexicalError::InvalidInt { - span: self.span(), - reason: err.kind().clone(), - }), + Err(err) => { + Token::Error(LexicalError::InvalidInt { span: self.span(), reason: *err.kind() }) + }, } } } diff --git a/parser/src/parser/grammar.lalrpop b/parser/src/parser/grammar.lalrpop index b06578f68..e05958009 100644 --- a/parser/src/parser/grammar.lalrpop +++ b/parser/src/parser/grammar.lalrpop @@ -560,7 +560,7 @@ SymbolAccessBaseSpanned: Span<(Identifier, AccessType)> = { SymbolAccessBase: (Identifier, AccessType) = { => (ident, AccessType::Default), - "[" "]" => (ident, AccessType::Slice(range)), + "[" "]" => (ident, AccessType::Slice(Box::new(range))), => (ident, AccessType::Index(idx)), => (ident, AccessType::Matrix(row, col)), // accessing an identifier used in a section declaration, like a named trace segment, e.g. $main @@ -611,7 +611,7 @@ Iterables: Vec = { Iterable: Expr = { => Expr::SymbolAccess(SymbolAccess::new(ident.span(), ident, AccessType::Default, 0)), => Expr::Range(range), - "[" "]" => Expr::SymbolAccess(SymbolAccess::new(span!(l, r), ident, AccessType::Slice(range), 0)), + "[" "]" => Expr::SymbolAccess(SymbolAccess::new(span!(l, r), ident, AccessType::Slice(Box::new(range)), 0)), => if let ScalarExpr::Call(call) = function_call { Expr::Call(call) } else { diff --git a/parser/src/parser/tests/mod.rs b/parser/src/parser/tests/mod.rs index aa1a162e1..1b18c60fc 100644 --- a/parser/src/parser/tests/mod.rs +++ b/parser/src/parser/tests/mod.rs @@ -426,7 +426,7 @@ macro_rules! slice { ScalarExpr::SymbolAccess(SymbolAccess { span: miden_diagnostics::SourceSpan::UNKNOWN, name: ResolvableIdentifier::Unresolved(NamespacedIdentifier::Binding(ident!($name))), - access_type: AccessType::Slice($range.into()), + access_type: AccessType::Slice(Box::new($range.into())), offset: 0, ty: None, }) @@ -436,7 +436,7 @@ macro_rules! slice { ScalarExpr::SymbolAccess(SymbolAccess { span: miden_diagnostics::SourceSpan::UNKNOWN, name: ResolvableIdentifier::Local(ident!($name)), - access_type: AccessType::Slice($range.into()), + access_type: AccessType::Slice(Box::new($range.into())), offset: 0, ty: Some($ty), }) diff --git a/parser/src/sema/semantic_analysis.rs b/parser/src/sema/semantic_analysis.rs index 09d89426f..b4bf9597e 100644 --- a/parser/src/sema/semantic_analysis.rs +++ b/parser/src/sema/semantic_analysis.rs @@ -444,9 +444,9 @@ impl VisitMut for SemanticAnalysis<'_> { self.current_module.clone().unwrap(), NamespacedIdentifier::Function(function.name), ); - let current_item_node_index = self.deps_graph.add_node(current_item); - for (referenced_item, ref_type) in self.referenced.iter() { - let referenced_item_node_index = self.deps_graph.add_node(referenced_item.clone()); + let current_item_node_index = self.get_node_index_or_add(¤t_item); + for (referenced_item, ref_type) in self.referenced.clone().iter() { + let referenced_item_node_index = self.get_node_index_or_add(referenced_item); self.deps_graph.add_edge( current_item_node_index, referenced_item_node_index, @@ -633,6 +633,15 @@ impl VisitMut for SemanticAnalysis<'_> { 0, ))))) .expect("unexpected scalar iterable"); + // Comprehension bindings are local variables holding values, not direct + // references to module-level declarations like periodic columns or constants. + // Convert these to Local bindings to ensure proper scoping. + let binding_ty = match binding_ty { + BindingType::PeriodicColumn(_) | BindingType::Constant(_) => { + BindingType::Local(binding_ty.ty().unwrap_or(Type::Felt)) + }, + other => other, + }; binding_tys.push((binding, iterable.span(), Some(binding_ty))); }, Err(InvalidAccessError::InvalidBinding) => {